[BlobStorage] Added back security policy for files in blobs

content/browser/blob_storage/blob_dispatcher_host_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/blob_storage/blob_dispatcher_host.h"
 
 #include <memory>
 #include <tuple>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "base/run_loop.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_file_system_context.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_test_sink.h"
 #include "ipc/message_filter.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
 #include "storage/common/blob_storage/blob_item_bytes_response.h"
 #include "storage/common/data_element.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 23 matching lines @@
 const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
 
 void ConstructionCompletePopulator(bool* succeeded_pointer,
                                    IPCBlobCreationCancelCode* reason_pointer,
                                    bool succeeded,
                                    IPCBlobCreationCancelCode reason) {
   *succeeded_pointer = succeeded;
   *reason_pointer = reason;
 }
 
+// TODO(dmurph): Create file test that verifies security policy.
 class TestableBlobDispatcherHost : public BlobDispatcherHost {
  public:
   TestableBlobDispatcherHost(ChromeBlobStorageContext* blob_storage_context,
+                             storage::FileSystemContext* file_system_context,
                              IPC::TestSink* sink)
-      : BlobDispatcherHost(blob_storage_context), sink_(sink) {
+      : BlobDispatcherHost(0 /* process_id */,
+                           make_scoped_refptr(blob_storage_context),
+                           make_scoped_refptr(file_system_context)),
+        sink_(sink) {
     this->SetMemoryConstantsForTesting(kTestBlobStorageIPCThresholdBytes,
                                        kTestBlobStorageMaxSharedMemoryBytes,
                                        kTestBlobStorageMaxFileSizeBytes);
   }
 
   bool Send(IPC::Message* message) override { return sink_->Send(message); }
 
   void ShutdownForBadMessage() override { shutdown_for_bad_message_ = true; }
 
   bool shutdown_for_bad_message_ = false;
 
  protected:
   ~TestableBlobDispatcherHost() override {}
 
  private:
   friend class base::RefCountedThreadSafe<TestableBlobDispatcherHost>;
 
   IPC::TestSink* sink_;
 };
 
 }  // namespace
 
 class BlobDispatcherHostTest : public testing::Test {
  protected:
   BlobDispatcherHostTest()
       : chrome_blob_storage_context_(
             ChromeBlobStorageContext::GetFor(&browser_context_)) {
-    host_ =
-        new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_);
+    file_system_context_ =
+        CreateFileSystemContextForTesting(NULL, base::FilePath());
+    host_ = new TestableBlobDispatcherHost(chrome_blob_storage_context_,
+                                           file_system_context_.get(), &sink_);
   }
   ~BlobDispatcherHostTest() override {}
 
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     if (!command_line->HasSwitch(switches::kDisableKillAfterBadIPC)) {
       command_line->AppendSwitch(switches::kDisableKillAfterBadIPC);
     }
     // We run the run loop to initialize the chrome blob storage context.
     base::RunLoop().RunUntilIdle();
@@ skipping 146 matching lines @@
 
   bool IsBeingBuiltInHost(const std::string& uuid) {
     return host_->async_builder_.IsBeingBuilt(uuid);
   }
 
   IPC::TestSink sink_;
   TestBrowserThreadBundle browser_thread_bundle_;
   TestBrowserContext browser_context_;
   ChromeBlobStorageContext* chrome_blob_storage_context_;
   BlobStorageContext* context_ = nullptr;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   scoped_refptr<TestableBlobDispatcherHost> host_;
 };
 
 TEST_F(BlobDispatcherHostTest, EmptyUUIDs) {
   host_->OnRegisterBlobUUID("", "", "", std::set<std::string>());
   ExpectAndResetBadMessage();
   host_->OnStartBuildingBlob("", std::vector<DataElement>());
   ExpectAndResetBadMessage();
   host_->OnMemoryItemResponse("", std::vector<BlobItemBytesResponse>());
   ExpectAndResetBadMessage();
@@ skipping 636 matching lines @@
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
   BlobItemBytesResponse response(0);
   std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
   std::vector<BlobItemBytesResponse> responses = {response};
 
   scoped_refptr<TestableBlobDispatcherHost> host2(
-      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_,
+                                     file_system_context_.get(), &sink_));
 
   // Delete host with another host having a referencing, then dereference on
   // second host. Verify we're still building it on first host, and then
   // verify that a building message from the renderer will kill it.
 
   // Test OnStartBuilding after double dereference.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
   host2->OnIncrementBlobRefCount(kId);
@@ skipping 62 matching lines @@
   // Data elements for our transfer & checking messages.
   DataElement element;
   element.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {element};
   DataElement referencing_element;
   referencing_element.SetToBlob(kId);
   std::vector<DataElement> referencing_elements = {referencing_element};
   std::set<std::string> referenced_blobs_set = {kId};
 
   scoped_refptr<TestableBlobDispatcherHost> host2(
-      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_,
+                                     file_system_context_.get(), &sink_));
 
   // We want to have a blob referencing another blob that is building, both on
   // the same host and a different host. We should successfully build all blobs
   // after the referenced blob is finished.
 
   // First we start the referenced blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
   EXPECT_TRUE(host_->IsInUseInHost(kId));
@@ skipping 42 matching lines @@
   const std::string kId("id");
   const std::string kSameHostReferencingId("id2");
   const std::string kDifferentHostReferencingId("id3");
   // Data elements for our transfer & checking messages.
   DataElement referencing_element;
   referencing_element.SetToBlob(kId);
   std::vector<DataElement> referencing_elements = {referencing_element};
   std::set<std::string> referenced_blobs_set = {kId};
 
   scoped_refptr<TestableBlobDispatcherHost> host2(
-      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_,
+                                     file_system_context_.get(), &sink_));
 
   // We want to have a blob referencing another blob that is building, both on
   // the same host and a different host. After we cancel the first blob, the
   // others should cancel as well.
 
   // First we start the referenced blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
   EXPECT_TRUE(host_->IsInUseInHost(kId));
@@ skipping 39 matching lines @@
   const std::string kId("id");
   const std::string kSameHostReferencingId("id2");
   const std::string kDifferentHostReferencingId("id3");
   // Data elements for our transfer & checking messages.
   DataElement referencing_element;
   referencing_element.SetToBlob(kId);
   std::vector<DataElement> referencing_elements = {referencing_element};
   std::set<std::string> referenced_blobs_set = {kId};
 
   scoped_refptr<TestableBlobDispatcherHost> host2(
-      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_,
+                                     file_system_context_.get(), &sink_));
 
   // We want to have a blob referencing another blob that is building, both on
   // the same host and a different host. When we destroy the host, the other
   // blob should cancel, as well as the blob on the other host.
 
   // First we start the referenced blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
   EXPECT_TRUE(host_->IsInUseInHost(kId));
@@ skipping 57 matching lines @@
   EXPECT_EQ(IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT,
             same_host_error_code);
   EXPECT_FALSE(other_host_built);
   EXPECT_EQ(IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT,
             other_host_error_code);
 
   sink_.ClearMessages();
 }
 
 }  // namespace content