Delete content::MockURLRequestDelegate.

content/browser/blob_storage/blob_url_request_job_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/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/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/fileapi/mock_url_request_delegate.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.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/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory_impl.h"
+#include "net/url_request/url_request_test_util.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation_context.h"
 #include "storage/browser/fileapi/file_system_url.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 208 matching lines @@
     expected_response_ = expected_response;
     TestRequest("GET", net::HttpRequestHeaders());
     EXPECT_EQ(expected_content_length,
               request_->response_headers()->GetContentLength());
   }
 
   void TestErrorRequest(int expected_status_code) {
     expected_status_code_ = expected_status_code;
     expected_response_ = "";
     TestRequest("GET", net::HttpRequestHeaders());
-    EXPECT_FALSE(url_request_delegate_.metadata());
+    EXPECT_FALSE(request_->response_info().metadata);
   }
 
   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_);
     request_->set_method(method);
     if (!extra_headers.IsEmpty())
       request_->SetExtraRequestHeaders(extra_headers);
     request_->Start();
 
     base::RunLoop().Run();
 
     // 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_.response_data());
+    EXPECT_EQ(expected_response_, url_request_delegate_.data_received());
   }
 
   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 55 matching lines @@
 
   base::MessageLoopForIO message_loop_;
   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_;
-  MockURLRequestDelegate url_request_delegate_;
+  net::TestDelegate url_request_delegate_;
   std::unique_ptr<net::URLRequest> request_;
 
   int expected_status_code_;
   std::string expected_response_;
 };
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   blob_data_->AppendData(kTestData1);
   TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1);
 }
@@ skipping 118 matching lines @@
   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(url_request_delegate_.metadata());
+  EXPECT_FALSE(request_->response_info().metadata);
 
   int64_t first = 0, last = 0, length = 0;
   EXPECT_TRUE(request_->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(url_request_delegate_.metadata());
+  EXPECT_FALSE(request_->response_info().metadata);
 
   int64_t total = GetTotalBlobLength();
   int64_t first = 0, last = 0, length = 0;
   EXPECT_TRUE(request_->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(url_request_delegate_.metadata());
+  EXPECT_FALSE(request_->response_info().metadata);
 
   int64_t first = 0, last = 0, length = 0;
   EXPECT_TRUE(request_->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_EQ(kTestContentType, content_type);
-  EXPECT_FALSE(url_request_delegate_.metadata());
+  EXPECT_FALSE(request_->response_info().metadata);
   size_t iter = 0;
   std::string content_disposition;
   EXPECT_TRUE(request_->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());
 
-  EXPECT_TRUE(url_request_delegate_.metadata());
-  std::string metadata(url_request_delegate_.metadata()->data(),
-                       url_request_delegate_.metadata()->size());
+  EXPECT_TRUE(request_->response_info().metadata);

[mattm, 2017/04/04 22:06:34]

While you're here, could change this to ASSERT_TRUE since the following lines
dereference the metadata pointer.

[pwnall, 2017/04/04 22:29:20]

Done.
Good catch, thank you very much!

+  std::string metadata(request_->response_info().metadata->data(),
+                       request_->response_info().metadata->size());
   EXPECT_EQ(std::string(kTestDiskCacheSideData), 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());
 
-  EXPECT_FALSE(url_request_delegate_.metadata());
+  EXPECT_FALSE(request_->response_info().metadata);
 }
 
 TEST_F(BlobURLRequestJobTest, BrokenBlob) {
   blob_handle_ = blob_context_.AddBrokenBlob(
       "uuid", "", "", storage::BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
   TestErrorRequest(500);
 }
 
 }  // namespace content