1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "content/browser/fileapi/fileapi_message_filter.h" 6 7 #include <string> 8 #include <vector> 9 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/shared_memory.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/process/process.h" 14 #include "content/browser/child_process_security_policy_impl.h" 15 #include "content/browser/fileapi/chrome_blob_storage_context.h" 16 #include "content/browser/streams/stream_registry.h" 17 #include "content/common/fileapi/file_system_messages.h" 18 #include "content/common/fileapi/webblob_messages.h" 19 #include "content/public/browser/browser_thread.h" 20 #include "content/public/common/common_param_traits.h" 21 #include "content/public/test/mock_render_process_host.h" 22 #include "content/public/test/test_browser_context.h" 23 #include "content/public/test/test_browser_thread.h" 24 #include "content/public/test/test_file_system_context.h" 25 #include "net/base/io_buffer.h" 26 #include "testing/gtest/include/gtest/gtest.h" 27 #include "webkit/browser/blob/blob_storage_context.h" 28 #include "webkit/browser/fileapi/file_system_context.h" 29 #include "webkit/common/blob/blob_data.h" 30 31 namespace content { 32 33 namespace { 34 35 const char kFakeBlobInternalUrlSpec[] = 36 "blob:blobinternal%3A///dc83ede4-9bbd-453b-be2e-60fd623fcc93"; 37 const char kFakeBlobInternalUrlSpec2[] = 38 "blob:blobinternal%3A///d28ae2e7-d233-4dda-9598-d135fe5d403e"; 39 40 const char kFakeContentType[] = "fake/type"; 41 42 } // namespace 43 44 class FileAPIMessageFilterTest : public testing::Test { 45 public: 46 FileAPIMessageFilterTest() 47 : io_browser_thread_(BrowserThread::IO, &message_loop_) { 48 } 49 50 protected: 51 virtual void SetUp() OVERRIDE { 52 file_system_context_ = 53 CreateFileSystemContextForTesting(NULL, base::FilePath()); 54 55 std::vector<fileapi::FileSystemType> types; 56 file_system_context_->GetFileSystemTypes(&types); 57 for (size_t i = 0; i < types.size(); ++i) { 58 ChildProcessSecurityPolicyImpl::GetInstance()-> 59 RegisterFileSystemPermissionPolicy( 60 types[i], 61 fileapi::FileSystemContext::GetPermissionPolicy(types[i])); 62 } 63 64 stream_context_ = StreamContext::GetFor(&browser_context_); 65 blob_storage_context_ = ChromeBlobStorageContext::GetFor(&browser_context_); 66 67 filter_ = new FileAPIMessageFilter( 68 0 /* process_id */, 69 browser_context_.GetRequestContext(), 70 file_system_context_.get(), 71 blob_storage_context_, 72 stream_context_); 73 74 // Complete initialization. 75 message_loop_.RunUntilIdle(); 76 } 77 78 base::MessageLoop message_loop_; 79 TestBrowserThread io_browser_thread_; 80 81 TestBrowserContext browser_context_; 82 scoped_refptr<fileapi::FileSystemContext> file_system_context_; 83 StreamContext* stream_context_; 84 ChromeBlobStorageContext* blob_storage_context_; 85 86 scoped_refptr<FileAPIMessageFilter> filter_; 87 }; 88 89 TEST_F(FileAPIMessageFilterTest, CloseChannelWithInflightRequest) { 90 scoped_refptr<FileAPIMessageFilter> filter( 91 new FileAPIMessageFilter( 92 0 /* process_id */, 93 browser_context_.GetRequestContext(), 94 file_system_context_.get(), 95 ChromeBlobStorageContext::GetFor(&browser_context_), 96 StreamContext::GetFor(&browser_context_))); 97 filter->OnChannelConnected(0); 98 99 // Complete initialization. 100 message_loop_.RunUntilIdle(); 101 102 int request_id = 0; 103 const GURL kUrl("filesystem:http://example.com/temporary/foo"); 104 FileSystemHostMsg_ReadMetadata read_metadata(request_id++, kUrl); 105 EXPECT_TRUE(filter->OnMessageReceived(read_metadata)); 106 107 // Close the filter while it has inflight request. 108 filter->OnChannelClosing(); 109 110 // This shouldn't cause DCHECK failure. 111 message_loop_.RunUntilIdle(); 112 } 113 114 TEST_F(FileAPIMessageFilterTest, MultipleFilters) { 115 scoped_refptr<FileAPIMessageFilter> filter1( 116 new FileAPIMessageFilter( 117 0 /* process_id */, 118 browser_context_.GetRequestContext(), 119 file_system_context_.get(), 120 ChromeBlobStorageContext::GetFor(&browser_context_), 121 StreamContext::GetFor(&browser_context_))); 122 scoped_refptr<FileAPIMessageFilter> filter2( 123 new FileAPIMessageFilter( 124 1 /* process_id */, 125 browser_context_.GetRequestContext(), 126 file_system_context_.get(), 127 ChromeBlobStorageContext::GetFor(&browser_context_), 128 StreamContext::GetFor(&browser_context_))); 129 filter1->OnChannelConnected(0); 130 filter2->OnChannelConnected(1); 131 132 // Complete initialization. 133 message_loop_.RunUntilIdle(); 134 135 int request_id = 0; 136 const GURL kUrl("filesystem:http://example.com/temporary/foo"); 137 FileSystemHostMsg_ReadMetadata read_metadata(request_id++, kUrl); 138 EXPECT_TRUE(filter1->OnMessageReceived(read_metadata)); 139 140 // Close the other filter before the request for filter1 is processed. 141 filter2->OnChannelClosing(); 142 143 // This shouldn't cause DCHECK failure. 144 message_loop_.RunUntilIdle(); 145 } 146 147 TEST_F(FileAPIMessageFilterTest, BuildEmptyStream) { 148 StreamRegistry* stream_registry = stream_context_->registry(); 149 150 const GURL kUrl(kFakeBlobInternalUrlSpec); 151 const GURL kDifferentUrl("blob:barfoo"); 152 153 EXPECT_EQ(NULL, stream_registry->GetStream(kUrl).get()); 154 155 StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType); 156 EXPECT_TRUE(filter_->OnMessageReceived(start_message)); 157 158 const int kBufferSize = 10; 159 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize)); 160 int bytes_read = 0; 161 162 scoped_refptr<Stream> stream = stream_registry->GetStream(kUrl); 163 // Stream becomes available for read right after registration. 164 ASSERT_FALSE(stream.get() == NULL); 165 EXPECT_EQ(Stream::STREAM_EMPTY, 166 stream->ReadRawData(buffer.get(), kBufferSize, &bytes_read)); 167 EXPECT_EQ(0, bytes_read); 168 stream = NULL; 169 170 StreamHostMsg_FinishBuilding finish_message(kUrl); 171 EXPECT_TRUE(filter_->OnMessageReceived(finish_message)); 172 173 stream = stream_registry->GetStream(kUrl); 174 ASSERT_FALSE(stream.get() == NULL); 175 EXPECT_EQ(Stream::STREAM_EMPTY, 176 stream->ReadRawData(buffer.get(), kBufferSize, &bytes_read)); 177 EXPECT_EQ(0, bytes_read); 178 179 // Run loop to finish transfer. 180 message_loop_.RunUntilIdle(); 181 182 EXPECT_EQ(Stream::STREAM_COMPLETE, 183 stream->ReadRawData(buffer.get(), kBufferSize, &bytes_read)); 184 EXPECT_EQ(0, bytes_read); 185 186 // Nothing should be returned for a URL we didn't use. 187 EXPECT_TRUE(stream_registry->GetStream(kDifferentUrl).get() == NULL); 188 } 189 190 TEST_F(FileAPIMessageFilterTest, BuildNonEmptyStream) { 191 StreamRegistry* stream_registry = stream_context_->registry(); 192 193 const GURL kUrl(kFakeBlobInternalUrlSpec); 194 195 EXPECT_EQ(NULL, stream_registry->GetStream(kUrl).get()); 196 197 StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType); 198 EXPECT_TRUE(filter_->OnMessageReceived(start_message)); 199 200 webkit_blob::BlobData::Item item; 201 const std::string kFakeData = "foobarbaz"; 202 item.SetToBytes(kFakeData.data(), kFakeData.size()); 203 StreamHostMsg_AppendBlobDataItem append_message(kUrl, item); 204 EXPECT_TRUE(filter_->OnMessageReceived(append_message)); 205 206 StreamHostMsg_FinishBuilding finish_message(kUrl); 207 EXPECT_TRUE(filter_->OnMessageReceived(finish_message)); 208 209 // Run loop to finish transfer and commit finalize command. 210 message_loop_.RunUntilIdle(); 211 212 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kFakeData.size())); 213 int bytes_read = 0; 214 215 scoped_refptr<Stream> stream = stream_registry->GetStream(kUrl); 216 ASSERT_FALSE(stream.get() == NULL); 217 218 EXPECT_EQ(Stream::STREAM_HAS_DATA, 219 stream->ReadRawData(buffer.get(), kFakeData.size(), &bytes_read)); 220 EXPECT_EQ(kFakeData.size(), static_cast<size_t>(bytes_read)); 221 EXPECT_EQ(kFakeData, std::string(buffer->data(), bytes_read)); 222 223 EXPECT_EQ(Stream::STREAM_COMPLETE, 224 stream->ReadRawData(buffer.get(), kFakeData.size(), &bytes_read)); 225 EXPECT_EQ(0, bytes_read); 226 } 227 228 TEST_F(FileAPIMessageFilterTest, BuildStreamWithSharedMemory) { 229 StreamRegistry* stream_registry = stream_context_->registry(); 230 231 const GURL kUrl(kFakeBlobInternalUrlSpec); 232 233 EXPECT_EQ(NULL, stream_registry->GetStream(kUrl).get()); 234 235 // For win, we need to set valid PID to the filter. 236 // OnAppendSharedMemoryToStream passes the peer process's handle to 237 // SharedMemory's constructor. If it's incorrect, DuplicateHandle won't work 238 // correctly. 239 filter_->set_peer_pid_for_testing(base::Process::Current().pid()); 240 241 StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType); 242 EXPECT_TRUE(filter_->OnMessageReceived(start_message)); 243 244 const std::string kFakeData = "foobarbaz"; 245 246 scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory); 247 ASSERT_TRUE(shared_memory->CreateAndMapAnonymous(kFakeData.size())); 248 memcpy(shared_memory->memory(), kFakeData.data(), kFakeData.size()); 249 StreamHostMsg_SyncAppendSharedMemory append_message( 250 kUrl, shared_memory->handle(), kFakeData.size()); 251 EXPECT_TRUE(filter_->OnMessageReceived(append_message)); 252 253 StreamHostMsg_FinishBuilding finish_message(kUrl); 254 EXPECT_TRUE(filter_->OnMessageReceived(finish_message)); 255 256 // Run loop to finish transfer and commit finalize command. 257 message_loop_.RunUntilIdle(); 258 259 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kFakeData.size())); 260 int bytes_read = 0; 261 262 scoped_refptr<Stream> stream = stream_registry->GetStream(kUrl); 263 ASSERT_FALSE(stream.get() == NULL); 264 265 EXPECT_EQ(Stream::STREAM_HAS_DATA, 266 stream->ReadRawData(buffer.get(), kFakeData.size(), &bytes_read)); 267 EXPECT_EQ(kFakeData.size(), static_cast<size_t>(bytes_read)); 268 EXPECT_EQ(kFakeData, std::string(buffer->data(), bytes_read)); 269 270 EXPECT_EQ(Stream::STREAM_COMPLETE, 271 stream->ReadRawData(buffer.get(), kFakeData.size(), &bytes_read)); 272 EXPECT_EQ(0, bytes_read); 273 } 274 275 TEST_F(FileAPIMessageFilterTest, BuildStreamAndCallOnChannelClosing) { 276 StreamRegistry* stream_registry = stream_context_->registry(); 277 278 const GURL kUrl(kFakeBlobInternalUrlSpec); 279 280 StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType); 281 EXPECT_TRUE(filter_->OnMessageReceived(start_message)); 282 283 ASSERT_FALSE(stream_registry->GetStream(kUrl).get() == NULL); 284 285 filter_->OnChannelClosing(); 286 287 ASSERT_EQ(NULL, stream_registry->GetStream(kUrl).get()); 288 } 289 290 TEST_F(FileAPIMessageFilterTest, CloneStream) { 291 StreamRegistry* stream_registry = stream_context_->registry(); 292 293 const GURL kUrl(kFakeBlobInternalUrlSpec); 294 const GURL kDestUrl(kFakeBlobInternalUrlSpec2); 295 296 StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType); 297 EXPECT_TRUE(filter_->OnMessageReceived(start_message)); 298 299 StreamHostMsg_Clone clone_message(kDestUrl, kUrl); 300 EXPECT_TRUE(filter_->OnMessageReceived(clone_message)); 301 302 ASSERT_FALSE(stream_registry->GetStream(kUrl).get() == NULL); 303 ASSERT_FALSE(stream_registry->GetStream(kDestUrl).get() == NULL); 304 } 305 306 } // namespace content 307
