[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>
 
@@ skipping 41 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,
                              IPC::TestSink* sink)
-      : BlobDispatcherHost(blob_storage_context), sink_(sink) {
+      : BlobDispatcherHost(
+          0 /* process_id */, blob_storage_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;
@@ skipping 202 matching lines @@
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle);
 
   DataElement expected;
   expected.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {expected};
   ExpectHandleEqualsData(handle.get(), elements);
 }
 
+
+TEST_F(BlobDispatcherHostTest, File) {
+  const std::string kId = "uuid1";
+  sink_.ClearMessages();
+  host_->OnRegisterBlobUUID(id, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            std::set<std::string>());
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
+  DataElement element;
+  element.SetToFile()
+  std::vector<DataElement> elements = {element};
+  host_->OnStartBuildingBlob(id, elements);
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
+  ExpectDone(id);
+  sink_.ClearMessages();
+  EXPECT_TRUE(context_->registry().HasEntry(kId));
+  std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
+  EXPECT_TRUE(handle);
+
+  DataElement expected;
+  expected.SetToBytes(kData, kDataSize);
+  std::vector<DataElement> elements = {expected};
+  ExpectHandleEqualsData(handle.get(), elements);
+}
+
+
 TEST_F(BlobDispatcherHostTest, RegularTransfer) {
   const std::string kId = "uuid1";
   AsyncBlobTransfer(kId);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle);
 
   DataElement expected;
   expected.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {expected};
@@ skipping 893 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