Implement CachedMetadata handling on MojoAsyncResourceHandler

content/browser/loader/mojo_async_resource_handler_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/loader/mojo_async_resource_handler.h"
 
 #include <string.h>
 
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "content/browser/loader/mock_resource_loader.h"
 #include "content/browser/loader/resource_controller.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
@@ skipping 147 matching lines @@
     num_on_response_started_calls_expectation_ = expectation;
   }
 
  private:
   int num_on_response_started_calls_ = 0;
   int num_on_response_started_calls_expectation_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate);
 };
 
-class MojoAsyncResourceHandlerWithCustomDataPipeOperations
+class MojoAsyncResourceHandlerWithStubOperations
     : public MojoAsyncResourceHandler {
  public:
-  MojoAsyncResourceHandlerWithCustomDataPipeOperations(
+  MojoAsyncResourceHandlerWithStubOperations(
       net::URLRequest* request,
       ResourceDispatcherHostImpl* rdh,
       mojom::URLLoaderAssociatedRequest mojo_request,
       mojom::URLLoaderClientAssociatedPtr url_loader_client)
       : MojoAsyncResourceHandler(request,
                                  rdh,
                                  std::move(mojo_request),
                                  std::move(url_loader_client)) {}
-  ~MojoAsyncResourceHandlerWithCustomDataPipeOperations() override {}
+  ~MojoAsyncResourceHandlerWithStubOperations() override {}
 
   void ResetBeginWriteExpectation() { is_begin_write_expectation_set_ = false; }
 
   void set_begin_write_expectation(MojoResult begin_write_expectation) {
     is_begin_write_expectation_set_ = true;
     begin_write_expectation_ = begin_write_expectation;
   }
   void set_end_write_expectation(MojoResult end_write_expectation) {
     is_end_write_expectation_set_ = true;
     end_write_expectation_ = end_write_expectation;
   }
   bool has_received_bad_message() const { return has_received_bad_message_; }
+  void SetMetadata(scoped_refptr<net::IOBufferWithSize> metadata) {
+    metadata_ = std::move(metadata);
+  }
 
  private:
   MojoResult BeginWrite(void** data, uint32_t* available) override {
     if (is_begin_write_expectation_set_)
       return begin_write_expectation_;
     return MojoAsyncResourceHandler::BeginWrite(data, available);
   }
   MojoResult EndWrite(uint32_t written) override {
     if (is_end_write_expectation_set_)
       return end_write_expectation_;
     return MojoAsyncResourceHandler::EndWrite(written);
   }
+  net::IOBufferWithSize* GetResponseMetadata(
+      net::URLRequest* request) override {
+    return metadata_.get();
+  }
+
   void ReportBadMessage(const std::string& error) override {
     has_received_bad_message_ = true;
   }
 
   bool is_begin_write_expectation_set_ = false;
   bool is_end_write_expectation_set_ = false;
   bool has_received_bad_message_ = false;
   MojoResult begin_write_expectation_ = MOJO_RESULT_UNKNOWN;
   MojoResult end_write_expectation_ = MOJO_RESULT_UNKNOWN;
+  scoped_refptr<net::IOBufferWithSize> metadata_;
 
-  DISALLOW_COPY_AND_ASSIGN(
-      MojoAsyncResourceHandlerWithCustomDataPipeOperations);
+  DISALLOW_COPY_AND_ASSIGN(MojoAsyncResourceHandlerWithStubOperations);
 };
 
 class TestURLLoaderFactory final : public mojom::URLLoaderFactory {
  public:
   TestURLLoaderFactory() {}
   ~TestURLLoaderFactory() override {}
 
   void CreateLoaderAndStart(
       mojom::URLLoaderAssociatedRequest request,
       int32_t routing_id,
@@ skipping 65 matching lines @@
         0, 0, request, url_loader_client_.CreateRemoteAssociatedPtrInfo(
                            url_loader_factory_.associated_group()));
 
     url_loader_factory_.FlushForTesting();
     DCHECK(weak_binding);
     TestURLLoaderFactory* factory_impl =
         static_cast<TestURLLoaderFactory*>(weak_binding->impl());
 
     mojom::URLLoaderClientAssociatedPtr client_ptr;
     client_ptr.Bind(factory_impl->PassClientPtrInfo());
-    handler_.reset(new MojoAsyncResourceHandlerWithCustomDataPipeOperations(
+    handler_.reset(new MojoAsyncResourceHandlerWithStubOperations(
         request_.get(), &rdh_, factory_impl->PassLoaderRequest(),
         std::move(client_ptr)));
     mock_loader_.reset(new MockResourceLoader(handler_.get()));
   }
 
   virtual ~MojoAsyncResourceHandlerTestBase() {
     MojoAsyncResourceHandler::SetAllocationSizeForTesting(
         MojoAsyncResourceHandler::kDefaultAllocationSize);
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 23 matching lines @@
 
   TestBrowserThreadBundle thread_bundle_;
   TestResourceDispatcherHostDelegate rdh_delegate_;
   ResourceDispatcherHostImpl rdh_;
   mojom::URLLoaderFactoryPtr url_loader_factory_;
   mojom::URLLoaderAssociatedPtr url_loader_proxy_;
   TestURLLoaderClient url_loader_client_;
   std::unique_ptr<TestBrowserContext> browser_context_;
   net::TestDelegate url_request_delegate_;
   std::unique_ptr<net::URLRequest> request_;
-  std::unique_ptr<MojoAsyncResourceHandlerWithCustomDataPipeOperations>
-      handler_;
+  std::unique_ptr<MojoAsyncResourceHandlerWithStubOperations> handler_;
   std::unique_ptr<MockResourceLoader> mock_loader_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoAsyncResourceHandlerTestBase);
 };
 
 class MojoAsyncResourceHandlerTest : public MojoAsyncResourceHandlerTestBase,
                                      public ::testing::Test {};
 
 // This test class is parameterized with MojoAsyncResourceHandler's allocation
 // size.
@@ skipping 12 matching lines @@
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnWillStart) {
   EXPECT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader_->OnWillStart(request_->url()));
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) {
   rdh_delegate_.set_num_on_response_started_calls_expectation(1);
+  scoped_refptr<net::IOBufferWithSize> metadata = new net::IOBufferWithSize(5);
+  memcpy(metadata->data(), "hello", 5);
+  handler_->SetMetadata(metadata);
+
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader_->OnWillStart(request_->url()));
 
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   response->head.content_length = 99;
   response->head.request_start =
       base::TimeTicks::UnixEpoch() + base::TimeDelta::FromDays(14);
   response->head.response_start =
       base::TimeTicks::UnixEpoch() + base::TimeDelta::FromDays(28);
 
   EXPECT_EQ(0, rdh_delegate_.num_on_response_started_calls());
   base::TimeTicks now1 = base::TimeTicks::Now();
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader_->OnResponseStarted(response));
   base::TimeTicks now2 = base::TimeTicks::Now();
 
   EXPECT_EQ(request_->creation_time(), response->head.request_start);
   EXPECT_LE(now1, response->head.response_start);
   EXPECT_LE(response->head.response_start, now2);
   EXPECT_EQ(1, rdh_delegate_.num_on_response_started_calls());
 
   url_loader_client_.RunUntilResponseReceived();
   EXPECT_EQ(response->head.request_start,
             url_loader_client_.response_head().request_start);
   EXPECT_EQ(response->head.response_start,
             url_loader_client_.response_head().response_start);
   EXPECT_EQ(99, url_loader_client_.response_head().content_length);
+
+  url_loader_client_.RunUntilCachedMetadataReceived();
+  EXPECT_EQ("hello", url_loader_client_.cached_metadata());
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnWillReadAndInFlightRequests) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
   EXPECT_EQ(1, rdh_.num_in_flight_requests_for_testing());
   handler_ = nullptr;
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
 }
@@ skipping 696 matching lines @@
     }
   }
   EXPECT_EQ("B", body);
 }
 
 INSTANTIATE_TEST_CASE_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
                         MojoAsyncResourceHandlerWithAllocationSizeTest,
                         ::testing::Values(8, 32 * 2014));
 }  // namespace
 }  // namespace content