[BlobStorage] BlobMemoryController & tests

content/browser/blob_storage/blob_async_transport_request_builder_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "storage/browser/blob/blob_async_transport_request_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace storage {
 namespace {
 
 const char kNewUUID[] = "newUUID";
-const base::FilePath kFuturePopulatingFilePath = base::FilePath::FromUTF8Unsafe(
-    std::string(BlobDataBuilder::kAppendFutureFileTemporaryFileName));
 const char kFakeBlobUUID[] = "fakeBlob";
 
 void AddMemoryItem(size_t length, std::vector<DataElement>* out) {
   DataElement bytes;
   bytes.SetToBytesDescription(length);
   out->push_back(bytes);
 }
 
 void AddShortcutMemoryItem(size_t length, std::vector<DataElement>* out) {
   DataElement bytes;
@@ skipping 50 matching lines @@
   EXPECT_EQ(1u, strategy.requests().size());
 
   auto& memory_item_request = strategy.requests().at(0);
   EXPECT_EQ(0u, memory_item_request.browser_item_index);
   EXPECT_EQ(0u, memory_item_request.browser_item_offset);
   EXPECT_EQ(
       BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 305ull, 0u, 0ull),
       memory_item_request.message);
 
   BlobDataBuilder expected_builder(kNewUUID);
-  expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 305,
-                              base::Time::FromDoubleT(0));
+  expected_builder.AppendFutureFile(0, 305, 0);
   EXPECT_EQ(expected_builder, builder);
 }
 
 TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFiles) {
   BlobAsyncTransportRequestBuilder strategy;
   BlobDataBuilder builder(kNewUUID);
   std::vector<DataElement> infos;
 
   AddMemoryItem(1000, &infos);
   strategy.InitializeForFileRequests(400,   // max_file_size
@@ skipping 22 matching lines @@
       memory_item_request.message);
 
   memory_item_request = strategy.requests().at(2);
   EXPECT_EQ(2u, memory_item_request.browser_item_index);
   EXPECT_EQ(0u, memory_item_request.browser_item_offset);
   EXPECT_EQ(
       BlobItemBytesRequest::CreateFileRequest(2u, 0u, 800ull, 200ull, 2u, 0ull),
       memory_item_request.message);
 
   BlobDataBuilder expected_builder(kNewUUID);
-  expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 400,
-                              base::Time::FromDoubleT(0));
-  expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 400,
-                              base::Time::FromDoubleT(0));
-  expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 200,
-                              base::Time::FromDoubleT(0));
+  expected_builder.AppendFutureFile(0, 400, 0);
+  expected_builder.AppendFutureFile(0, 400, 1);
+  expected_builder.AppendFutureFile(0, 200, 2);
   EXPECT_EQ(expected_builder, builder);
 }
 
 TEST(BlobAsyncTransportRequestBuilderTest,
      TestLargeBlocksConsolidatingInFiles) {
   BlobAsyncTransportRequestBuilder strategy;
   BlobDataBuilder builder(kNewUUID);
   std::vector<DataElement> infos;
 
   // We should have 3 storage items for the memory, two files, 400 each.
@@ skipping 197 matching lines @@
   // We still populate future data, as the strategy assumes we will be
   // requesting the data.
   BlobDataBuilder expected_builder(kNewUUID);
   expected_builder.AppendFutureData(10);
   expected_builder.AppendBlob(kFakeBlobUUID);
   expected_builder.AppendFutureData(80);
   EXPECT_EQ(expected_builder, builder);
 }
 }  // namespace
 }  // namespace storage