Add support for reading blobs when using the network service.

content/browser/blob_storage/blob_url_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <limits>
 #include <memory>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "content/browser/blob_storage/blob_url_loader_factory.h"
+#include "content/browser/loader/test_url_loader_client.h"
+#include "content/browser/url_loader_factory_getter.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "mojo/common/data_pipe_utils.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 109 matching lines @@
                                    test_->GetHandleFromBuilder(),
                                    test_->file_system_context_.get(),
                                    base::ThreadTaskRunnerHandle::Get().get());
     }
 
    private:
     BlobURLRequestJobTest* test_;
   };
 
   BlobURLRequestJobTest()
-      : blob_data_(new BlobDataBuilder("uuid")), expected_status_code_(0) {}
+      : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
+        blob_data_(new BlobDataBuilder("uuid")),
+        response_error_code_(net::OK),
+        expected_status_code_(0) {}
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     temp_file1_ = temp_dir_.GetPath().AppendASCII("BlobFile1.dat");
     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
               base::WriteFile(temp_file1_, kTestFileData1,
                               arraysize(kTestFileData1) - 1));
     base::File::Info file_info1;
     base::GetFileInfo(temp_file1_, &file_info1);
@@ skipping 11 matching lines @@
     disk_cache_entry_ = CreateDiskCacheEntry(
         disk_cache_backend_.get(), kTestDiskCacheKey1, kTestDiskCacheData1);
 
     url_request_job_factory_.SetProtocolHandler(
         "blob", base::MakeUnique<MockProtocolHandler>(this));
     url_request_context_.set_job_factory(&url_request_job_factory_);
   }
 
   void TearDown() override {
     blob_handle_.reset();
-    request_.reset();
     // Clean up for ASAN
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void SetUpFileSystem() {
     // Prepare file system.
     file_system_context_ =
         CreateFileSystemContextForTesting(NULL, temp_dir_.GetPath());
 
@@ skipping 49 matching lines @@
     ASSERT_EQ(base::File::FILE_OK, result);
     ASSERT_TRUE(root.is_valid());
     file_system_root_url_ = root;
   }
 
   void TestSuccessNonrangeRequest(const std::string& expected_response,
                                   int64_t expected_content_length) {
     expected_status_code_ = 200;
     expected_response_ = expected_response;
     TestRequest("GET", net::HttpRequestHeaders());
-    EXPECT_EQ(expected_content_length,
-              request_->response_headers()->GetContentLength());
+    EXPECT_EQ(expected_content_length, response_headers_->GetContentLength());
   }
 
   void TestErrorRequest(int expected_status_code) {
     expected_status_code_ = expected_status_code;
     expected_response_ = "";
     TestRequest("GET", net::HttpRequestHeaders());
-    EXPECT_FALSE(request_->response_info().metadata);
+    EXPECT_TRUE(response_metadata_.empty());
   }
 
   void TestRequest(const std::string& method,
                    const net::HttpRequestHeaders& extra_headers) {
-    request_ = url_request_context_.CreateRequest(
-        GURL("blob:blah"), net::DEFAULT_PRIORITY, &url_request_delegate_,
-        TRAFFIC_ANNOTATION_FOR_TESTS);
-    request_->set_method(method);
-    if (!extra_headers.IsEmpty())
-      request_->SetExtraRequestHeaders(extra_headers);
-    request_->Start();
+    GURL url("blob:blah");
 
-    base::RunLoop().Run();
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableNetworkService)) {
+      GetHandleFromBuilder();  // To add to StorageContext.
+      const_cast<storage::BlobStorageRegistry&>(blob_context_.registry())
+          .CreateUrlMapping(url, blob_data_->uuid());
+      ResourceRequest request;
+      request.url = url;
+      request.method = method;
+      if (!extra_headers.IsEmpty())
+        request.headers = extra_headers.ToString();
+
+      mojom::URLLoaderAssociatedPtr url_loader;
+      TestURLLoaderClient url_loader_client;
+      scoped_refptr<BlobURLLoaderFactory> factory = new BlobURLLoaderFactory(
+          base::Bind(&BlobURLRequestJobTest::GetStorageContext,
+                     base::Unretained(this)),
+          file_system_context_);
+      base::RunLoop().RunUntilIdle();
+      factory->CreateLoaderAndStart(mojo::MakeRequest(&url_loader), 0, 0,
+                                    mojom::kURLLoadOptionNone, request,
+                                    url_loader_client.CreateInterfacePtr());
+      url_loader_client.RunUntilComplete();
+
+      if (url_loader_client.response_body().is_valid()) {
+        EXPECT_TRUE(mojo::common::BlockingCopyToString(
+            url_loader_client.response_body_release(), &response_));
+      }
+      response_headers_ = url_loader_client.response_head().headers;
+      response_metadata_ = url_loader_client.cached_metadata();
+      response_error_code_ = url_loader_client.completion_status().error_code;
+    } else {
+      std::unique_ptr<net::URLRequest> request =
+          url_request_context_.CreateRequest(url, net::DEFAULT_PRIORITY,
+                                             &url_request_delegate_,
+                                             TRAFFIC_ANNOTATION_FOR_TESTS);
+      request->set_method(method);
+      if (!extra_headers.IsEmpty())
+        request->SetExtraRequestHeaders(extra_headers);
+      request->Start();
+
+      base::RunLoop().Run();
+      response_ = url_request_delegate_.data_received();
+      response_headers_ = request->response_headers();
+      if (request->response_info().metadata) {
+        response_metadata_ =
+            std::string(request->response_info().metadata->data(),
+                        request->response_info().metadata->size());
+      }
+
+      response_error_code_ = url_request_delegate_.request_status();
+    }
 
     // Verify response.
-    EXPECT_EQ(net::OK, url_request_delegate_.request_status());
-    EXPECT_EQ(expected_status_code_,
-              request_->response_headers()->response_code());
-    EXPECT_EQ(expected_response_, url_request_delegate_.data_received());
+    EXPECT_EQ(net::OK, response_error_code_);
+    EXPECT_EQ(expected_status_code_, response_headers_->response_code());
+    EXPECT_EQ(expected_response_, response_);
   }
 
   void BuildComplicatedData(std::string* expected_result) {
     blob_data_->AppendData(kTestData1 + 1, 2);
     *expected_result = std::string(kTestData1 + 1, 2);
 
     blob_data_->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
     *expected_result += std::string(kTestFileData1 + 2, 3);
 
     blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(),
@@ skipping 32 matching lines @@
     const auto& items = data->items();
     for (const auto& item : items) {
       int64_t length = base::checked_cast<int64_t>(item->length());
       CHECK(length <= std::numeric_limits<int64_t>::max() - total);
       total += length;
     }
     return total;
   }
 
  protected:
+  base::WeakPtr<storage::BlobStorageContext> GetStorageContext() {
+    return blob_context_.AsWeakPtr();
+  }
+
   base::ScopedTempDir temp_dir_;
   base::FilePath temp_file1_;
   base::FilePath temp_file2_;
   base::Time temp_file_modification_time1_;
   base::Time temp_file_modification_time2_;
   GURL file_system_root_url_;
   GURL temp_file_system_file1_;
   GURL temp_file_system_file2_;
   base::Time temp_file_system_file_modification_time1_;
   base::Time temp_file_system_file_modification_time2_;
 
   std::unique_ptr<disk_cache::Backend> disk_cache_backend_;
   disk_cache::ScopedEntryPtr disk_cache_entry_;
 
-  base::MessageLoopForIO message_loop_;
+  TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   storage::BlobStorageContext blob_context_;
   std::unique_ptr<storage::BlobDataHandle> blob_handle_;
   std::unique_ptr<BlobDataBuilder> blob_data_;
   std::unique_ptr<BlobDataSnapshot> blob_data_snapshot_;
   net::URLRequestJobFactoryImpl url_request_job_factory_;
   net::URLRequestContext url_request_context_;
   net::TestDelegate url_request_delegate_;
-  std::unique_ptr<net::URLRequest> request_;
+  std::string response_;
+  int response_error_code_;
+  scoped_refptr<net::HttpResponseHeaders> response_headers_;
+  std::string response_metadata_;
 
   int expected_status_code_;
   std::string expected_response_;
 };
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   blob_data_->AppendData(kTestData1);
   TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1);
 }
 
@@ skipping 115 matching lines @@
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
                           net::HttpByteRange::Bounded(5, 10).GetHeaderValue());
   expected_status_code_ = 206;
   expected_response_ = result.substr(5, 10 - 5 + 1);
   TestRequest("GET", extra_headers);
 
-  EXPECT_EQ(6, request_->response_headers()->GetContentLength());
-  EXPECT_FALSE(request_->response_info().metadata);
+  EXPECT_EQ(6, response_headers_->GetContentLength());
+  EXPECT_TRUE(response_metadata_.empty());
 
   int64_t first = 0, last = 0, length = 0;
-  EXPECT_TRUE(request_->response_headers()->GetContentRangeFor206(&first, &last,
-                                                                  &length));
+  EXPECT_TRUE(response_headers_->GetContentRangeFor206(&first, &last, &length));
   EXPECT_EQ(5, first);
   EXPECT_EQ(10, last);
   EXPECT_EQ(GetTotalBlobLength(), length);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
                           net::HttpByteRange::Suffix(10).GetHeaderValue());
   expected_status_code_ = 206;
   expected_response_ = result.substr(result.length() - 10);
   TestRequest("GET", extra_headers);
 
-  EXPECT_EQ(10, request_->response_headers()->GetContentLength());
-  EXPECT_FALSE(request_->response_info().metadata);
+  EXPECT_EQ(10, response_headers_->GetContentLength());
+  EXPECT_TRUE(response_metadata_.empty());
 
   int64_t total = GetTotalBlobLength();
   int64_t first = 0, last = 0, length = 0;
-  EXPECT_TRUE(request_->response_headers()->GetContentRangeFor206(&first, &last,
-                                                                  &length));
+  EXPECT_TRUE(response_headers_->GetContentRangeFor206(&first, &last, &length));
   EXPECT_EQ(total - 10, first);
   EXPECT_EQ(total - 1, last);
   EXPECT_EQ(total, length);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest3) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
                           net::HttpByteRange::Bounded(0, 2).GetHeaderValue());
   expected_status_code_ = 206;
   expected_response_ = result.substr(0, 3);
   TestRequest("GET", extra_headers);
 
-  EXPECT_EQ(3, request_->response_headers()->GetContentLength());
-  EXPECT_FALSE(request_->response_info().metadata);
+  EXPECT_EQ(3, response_headers_->GetContentLength());
+  EXPECT_TRUE(response_metadata_.empty());
 
   int64_t first = 0, last = 0, length = 0;
-  EXPECT_TRUE(request_->response_headers()->GetContentRangeFor206(&first, &last,
-                                                                  &length));
+  EXPECT_TRUE(response_headers_->GetContentRangeFor206(&first, &last, &length));
   EXPECT_EQ(0, first);
   EXPECT_EQ(2, last);
   EXPECT_EQ(GetTotalBlobLength(), length);
 }
 
 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
   blob_data_->set_content_type(kTestContentType);
   blob_data_->set_content_disposition(kTestContentDisposition);
   blob_data_->AppendData(kTestData1);
   expected_status_code_ = 200;
   expected_response_ = kTestData1;
   TestRequest("GET", net::HttpRequestHeaders());
 
   std::string content_type;
-  EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
+  EXPECT_TRUE(response_headers_->GetMimeType(&content_type));
   EXPECT_EQ(kTestContentType, content_type);
-  EXPECT_FALSE(request_->response_info().metadata);
+  EXPECT_TRUE(response_metadata_.empty());
   size_t iter = 0;
   std::string content_disposition;
-  EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
-      &iter, "Content-Disposition", &content_disposition));
+  EXPECT_TRUE(response_headers_->EnumerateHeader(&iter, "Content-Disposition",
+                                                 &content_disposition));
   EXPECT_EQ(kTestContentDisposition, content_disposition);
 }
 
 TEST_F(BlobURLRequestJobTest, TestSideData) {
   disk_cache::ScopedEntryPtr disk_cache_entry_with_side_data =
       CreateDiskCacheEntryWithSideData(disk_cache_backend_.get(),
                                        kTestDiskCacheKey2, kTestDiskCacheData2,
                                        kTestDiskCacheSideData);
   blob_data_->AppendDiskCacheEntryWithSideData(
       new EmptyDataHandle(), disk_cache_entry_with_side_data.get(),
       kTestDiskCacheStreamIndex, kTestDiskCacheSideStreamIndex);
   expected_status_code_ = 200;
   expected_response_ = kTestDiskCacheData2;
   TestRequest("GET", net::HttpRequestHeaders());
   EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1),
-            request_->response_headers()->GetContentLength());
+            response_headers_->GetContentLength());
 
-  ASSERT_TRUE(request_->response_info().metadata);
-  std::string metadata(request_->response_info().metadata->data(),
-                       request_->response_info().metadata->size());
-  EXPECT_EQ(std::string(kTestDiskCacheSideData), metadata);
+  EXPECT_EQ(std::string(kTestDiskCacheSideData), response_metadata_);
 }
 
 TEST_F(BlobURLRequestJobTest, TestZeroSizeSideData) {
   disk_cache::ScopedEntryPtr disk_cache_entry_with_side_data =
       CreateDiskCacheEntryWithSideData(disk_cache_backend_.get(),
                                        kTestDiskCacheKey2, kTestDiskCacheData2,
                                        "");
   blob_data_->AppendDiskCacheEntryWithSideData(
       new EmptyDataHandle(), disk_cache_entry_with_side_data.get(),
       kTestDiskCacheStreamIndex, kTestDiskCacheSideStreamIndex);
   expected_status_code_ = 200;
   expected_response_ = kTestDiskCacheData2;
   TestRequest("GET", net::HttpRequestHeaders());
   EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1),
-            request_->response_headers()->GetContentLength());
+            response_headers_->GetContentLength());
 
-  EXPECT_FALSE(request_->response_info().metadata);
+  EXPECT_TRUE(response_metadata_.empty());
 }
 
 TEST_F(BlobURLRequestJobTest, BrokenBlob) {
   blob_handle_ = blob_context_.AddBrokenBlob(
       "uuid", "", "", storage::BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
   TestErrorRequest(500);
 }
 
 }  // namespace content