Merge: Allow offsets in blobs larger than 2GB on 32 bit Chromium builds.

content/browser/fileapi/blob_storage_context_unittest.cc

 // Copyright 2014 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 "storage/browser/blob/blob_storage_context.h"
+
+#include <limits>
+#include <string>
+
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "content/browser/fileapi/blob_storage_host.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
+#include "storage/browser/blob/blob_data_item.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
-#include "storage/browser/blob/blob_storage_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::BlobDataBuilder;
 using storage::BlobDataHandle;
+using storage::BlobDataItem;
 using storage::BlobDataSnapshot;
 using storage::BlobStorageContext;
 using storage::DataElement;
 
 namespace content {
-
 namespace {
-// This is necessary to clean up the blobs after the handles are released.
-void RunEventLoopTillIdle() {
-  base::RunLoop run_loop;
-  run_loop.RunUntilIdle();
-}
 
 void SetupBasicBlob(BlobStorageHost* host, const std::string& id) {
   EXPECT_TRUE(host->StartBuildingBlob(id));
   DataElement item;
   item.SetToBytes("1", 1);
   EXPECT_TRUE(host->AppendBlobDataItem(id, item));
   EXPECT_TRUE(host->FinishBuildingBlob(id, "text/plain"));
   EXPECT_FALSE(host->StartBuildingBlob(id));
 }
+
 }  // namespace
 
 TEST(BlobStorageContextTest, IncrementDecrementRef) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
   const std::string kId("id");
   SetupBasicBlob(&host, kId);
 
   // Make sure it's there, finish building implies a ref of one.
   scoped_ptr<BlobDataHandle> blob_data_handle;
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Make sure its still there after inc/dec.
   EXPECT_TRUE(host.IncrementBlobRefCount(kId));
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Make sure it goes away in the end.
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_FALSE(blob_data_handle);
   EXPECT_FALSE(host.DecrementBlobRefCount(kId));
   EXPECT_FALSE(host.IncrementBlobRefCount(kId));
 }
 
 TEST(BlobStorageContextTest, CancelBuildingBlob) {
@@ skipping 30 matching lines @@
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
 
   // Should still be there due to the handle.
   scoped_ptr<BlobDataHandle> another_handle =
       context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(another_handle);
 
   // Should disappear after dropping both handles.
   blob_data_handle.reset();
   another_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_FALSE(blob_data_handle);
 }
 
 TEST(BlobStorageContextTest, MemoryUsage) {
   const std::string kId1("id1");
   const std::string kId2("id2");
 
   base::MessageLoop fake_io_message_loop;
@@ skipping 13 matching lines @@
   EXPECT_EQ(0lu, context.memory_usage());
 
   scoped_ptr<BlobDataHandle> blob_data_handle =
       context.AddFinishedBlob(&builder1);
   EXPECT_EQ(10lu, context.memory_usage());
   scoped_ptr<BlobDataHandle> blob_data_handle2 =
       context.AddFinishedBlob(&builder2);
   EXPECT_EQ(10lu, context.memory_usage());
 
   blob_data_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(10lu, context.memory_usage());
   blob_data_handle2.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0lu, context.memory_usage());
 }
 
 TEST(BlobStorageContextTest, AddFinishedBlob) {
   const std::string kId1("id1");
   const std::string kId2("id12");
   const std::string kId2Prime("id2.prime");
   const std::string kId3("id3");
   const std::string kId3Prime("id3.prime");
@@ skipping 18 matching lines @@
 
   ASSERT_TRUE(blob_data_handle);
   ASSERT_TRUE(blob_data_handle2);
   scoped_ptr<BlobDataSnapshot> data1 = blob_data_handle->CreateSnapshot();
   scoped_ptr<BlobDataSnapshot> data2 = blob_data_handle2->CreateSnapshot();
   EXPECT_EQ(*data1, builder1);
   EXPECT_EQ(*data2, canonicalized_blob_data2);
   blob_data_handle.reset();
   data2.reset();
 
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   blob_data_handle = context.GetBlobDataFromUUID(kId1);
   EXPECT_FALSE(blob_data_handle);
   EXPECT_TRUE(blob_data_handle2);
   data2 = blob_data_handle2->CreateSnapshot();
   EXPECT_EQ(*data2, canonicalized_blob_data2);
 
   // Test shared elements stick around.
   BlobDataBuilder builder3(kId3);
   builder3.AppendBlob(kId2);
   builder3.AppendBlob(kId2);
   scoped_ptr<BlobDataHandle> blob_data_handle3 =
       context.AddFinishedBlob(&builder3);
   blob_data_handle2.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   blob_data_handle2 = context.GetBlobDataFromUUID(kId2);
   EXPECT_FALSE(blob_data_handle2);
   EXPECT_TRUE(blob_data_handle3);
   scoped_ptr<BlobDataSnapshot> data3 = blob_data_handle3->CreateSnapshot();
 
   BlobDataBuilder canonicalized_blob_data3(kId3Prime);
   canonicalized_blob_data3.AppendData("Data2");
   canonicalized_blob_data3.AppendData(" is the best");
   canonicalized_blob_data3.AppendData("Data2");
   canonicalized_blob_data3.AppendData(" is the best");
   EXPECT_EQ(*data3, canonicalized_blob_data3);
 
   blob_data_handle.reset();
   blob_data_handle2.reset();
   blob_data_handle3.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST(BlobStorageContextTest, AddFinishedBlob_LargeOffset) {
+  // A value which does not fit in a 4-byte data type. Used to confirm that
+  // large values are supported on 32-bit Chromium builds. Regression test for:
+  // crbug.com/458122.
+  const uint64_t kLargeSize = std::numeric_limits<uint64_t>::max();
+
+  const uint64_t kBlobLength = 5;
+  const std::string kId1("id1");
+  const std::string kId2("id2");
+  base::MessageLoop fake_io_message_loop;
+
+  BlobDataBuilder builder1(kId1);
+  builder1.AppendFileSystemFile(GURL(), 0, kLargeSize, base::Time::Now());
+
+  BlobDataBuilder builder2(kId2);
+  builder2.AppendBlob(kId1, kLargeSize - kBlobLength, kBlobLength);
+
+  BlobStorageContext context;
+  scoped_ptr<BlobDataHandle> blob_data_handle1 =
+      context.AddFinishedBlob(&builder1);
+  scoped_ptr<BlobDataHandle> blob_data_handle2 =
+      context.AddFinishedBlob(&builder2);
+
+  ASSERT_TRUE(blob_data_handle1);
+  ASSERT_TRUE(blob_data_handle2);
+  scoped_ptr<BlobDataSnapshot> data = blob_data_handle2->CreateSnapshot();
+  ASSERT_EQ(1u, data->items().size());
+  const scoped_refptr<BlobDataItem> item = data->items()[0];
+  EXPECT_EQ(kLargeSize - kBlobLength, item->offset());
+  EXPECT_EQ(kBlobLength, item->length());
+
+  blob_data_handle1.reset();
+  blob_data_handle2.reset();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST(BlobStorageContextTest, CompoundBlobs) {
   const std::string kId1("id1");
   const std::string kId2("id2");
   const std::string kId2Prime("id2.prime");
 
   base::MessageLoop fake_io_message_loop;
 
   // Setup a set of blob data for testing.
@@ skipping 33 matching lines @@
   EXPECT_EQ(*data, blob_data1);
 
   // Test a blob composed in part with another blob.
   blob_data_handle = context.AddFinishedBlob(&blob_data2);
   data = blob_data_handle->CreateSnapshot();
   ASSERT_TRUE(blob_data_handle);
   ASSERT_TRUE(data);
   EXPECT_EQ(*data, canonicalized_blob_data2);
 
   blob_data_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST(BlobStorageContextTest, PublicBlobUrls) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
   const std::string kId("id");
   SetupBasicBlob(&host, kId);
 
   // Now register a url for that blob.
   GURL kUrl("blob:id");
   EXPECT_TRUE(host.RegisterPublicBlobURL(kUrl, kId));
   scoped_ptr<BlobDataHandle> blob_data_handle =
       context.GetBlobDataFromPublicURL(kUrl);
   ASSERT_TRUE(blob_data_handle.get());
   EXPECT_EQ(kId, blob_data_handle->uuid());
   scoped_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
   blob_data_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The url registration should keep the blob alive even after
   // explicit references are dropped.
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
   blob_data_handle = context.GetBlobDataFromPublicURL(kUrl);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
-  RunEventLoopTillIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Finally get rid of the url registration and the blob.
   EXPECT_TRUE(host.RevokePublicBlobURL(kUrl));
   blob_data_handle = context.GetBlobDataFromPublicURL(kUrl);
   EXPECT_TRUE(!blob_data_handle.get());
   EXPECT_FALSE(host.RevokePublicBlobURL(kUrl));
 }
 
 TEST(BlobStorageContextTest, HostCleanup) {
   BlobStorageContext context;
@@ skipping 31 matching lines @@
   EXPECT_FALSE(host.FinishBuildingBlob(kId, "text/plain"));
   EXPECT_FALSE(host.RegisterPublicBlobURL(kUrl, kId));
   EXPECT_FALSE(host.IncrementBlobRefCount(kId));
   EXPECT_FALSE(host.DecrementBlobRefCount(kId));
   EXPECT_FALSE(host.RevokePublicBlobURL(kUrl));
 }
 
 // TODO(michaeln): tests for the depcrecated url stuff
 
 }  // namespace content