Use a proper URLLoaderAssociatedRequest in MojoAsyncResourceHandler tests

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>
 
@@ skipping 15 matching lines @@
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/stream_info.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/types.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/url_request.h"
@@ skipping 214 matching lines @@
 
   bool is_begin_write_expectation_set_ = false;
   bool is_end_write_expectation_set_ = false;
   MojoResult begin_write_expectation_ = MOJO_RESULT_UNKNOWN;
   MojoResult end_write_expectation_ = MOJO_RESULT_UNKNOWN;
 
   DISALLOW_COPY_AND_ASSIGN(
       MojoAsyncResourceHandlerWithCustomDataPipeOperations);
 };
 
+class TestURLLoaderFactory final : public mojom::URLLoaderFactory {
+ public:
+  TestURLLoaderFactory() {}
+  ~TestURLLoaderFactory() override {}
+
+  void CreateLoaderAndStart(
+      mojom::URLLoaderAssociatedRequest request,
+      int32_t routing_id,
+      int32_t request_id,
+      const ResourceRequest& url_request,
+      mojom::URLLoaderClientAssociatedPtrInfo client_ptr_info) override {
+    loader_request_ = std::move(request);
+    client_ptr_info_ = std::move(client_ptr_info);
+  }
+
+  mojom::URLLoaderAssociatedRequest PassLoaderRequest() {
+    return std::move(loader_request_);
+  }
+
+  mojom::URLLoaderClientAssociatedPtrInfo PassClientPtrInfo() {
+    return std::move(client_ptr_info_);
+  }
+
+  void SyncLoad(int32_t routing_id,
+                int32_t request_id,
+                const ResourceRequest& url_request,
+                const SyncLoadCallback& callback) override {
+    NOTREACHED();
+  }
+
+ private:
+  mojom::URLLoaderAssociatedRequest loader_request_;
+  mojom::URLLoaderClientAssociatedPtrInfo client_ptr_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestURLLoaderFactory);
+};
+
 class MojoAsyncResourceHandlerTestBase {
  public:
   MojoAsyncResourceHandlerTestBase()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         browser_context_(new TestBrowserContext()) {
     MojoAsyncResourceHandler::SetAllocationSizeForTesting(32 * 1024);
     rdh_.SetDelegate(&rdh_delegate_);
 
     url_request_delegate_.reset(new net::TestDelegate());
     net::URLRequestContext* request_context =
         browser_context_->GetResourceContext()->GetRequestContext();
     request_ = request_context->CreateRequest(
         net::URLRequestFailedJob::GetMockHttpUrl(net::ERR_TIMED_OUT),
         net::DEFAULT_PRIORITY, url_request_delegate_.get());
     ResourceRequestInfo::AllocateForTesting(
         request_.get(),                          // request
         RESOURCE_TYPE_XHR,                       // resource_type
         browser_context_->GetResourceContext(),  // context
         2,                                       // render_process_id
         0,                                       // render_view_id
         0,                                       // render_frame_id
         true,                                    // is_main_frame
         false,                                   // parent_is_main_frame
         false,                                   // allow_download
         true,                                    // is_async
         false                                    // is_using_lofi
         );
-    mojom::URLLoaderClientAssociatedPtrInfo client_ptr_info =
-        url_loader_client_.CreateLocalAssociatedPtrInfo();
+
+    ResourceRequest request;
+    base::WeakPtr<mojo::StrongBinding<mojom::URLLoaderFactory>> weak_binding =
+        mojo::MakeStrongBinding(base::MakeUnique<TestURLLoaderFactory>(),
+                                mojo::GetProxy(&url_loader_factory_));
+
+    url_loader_factory_->CreateLoaderAndStart(
+        mojo::GetProxy(&url_loader_proxy_,
+                       url_loader_factory_.associated_group()),
+        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(std::move(client_ptr_info));
+    client_ptr.Bind(factory_impl->PassClientPtrInfo());
     handler_.reset(new MojoAsyncResourceHandlerWithCustomDataPipeOperations(
-        request_.get(), &rdh_, nullptr, std::move(client_ptr)));
+        request_.get(), &rdh_, factory_impl->PassLoaderRequest(),
+        std::move(client_ptr)));
     handler_->SetController(&resource_controller_);
   }
 
   virtual ~MojoAsyncResourceHandlerTestBase() {
     net::URLRequestFilter::GetInstance()->ClearHandlers();
     MojoAsyncResourceHandler::SetAllocationSizeForTesting(
         MojoAsyncResourceHandler::kDefaultAllocationSize);
     base::RunLoop().RunUntilIdle();
   }
 
@@ skipping 31 matching lines @@
       ADD_FAILURE() << "URLLoaderClient unexpectedly gets a response.";
       return false;
     }
     url_loader_client_.RunUntilResponseReceived();
     return true;
   }
 
   TestBrowserThreadBundle thread_bundle_;
   TestResourceDispatcherHostDelegate rdh_delegate_;
   ResourceDispatcherHostImpl rdh_;
+  mojom::URLLoaderFactoryPtr url_loader_factory_;
+  mojom::URLLoaderAssociatedPtr url_loader_proxy_;
   TestURLLoaderClient url_loader_client_;
   TestResourceController resource_controller_;
   std::unique_ptr<TestBrowserContext> browser_context_;
   std::unique_ptr<net::TestDelegate> url_request_delegate_;
   std::unique_ptr<net::URLRequest> request_;
   std::unique_ptr<MojoAsyncResourceHandlerWithCustomDataPipeOperations>
       handler_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoAsyncResourceHandlerTestBase);
 };
@@ skipping 775 matching lines @@
     }
   }
   EXPECT_EQ("B", body);
 }
 
 INSTANTIATE_TEST_CASE_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
                         MojoAsyncResourceHandlerWithAllocationSizeTest,
                         ::testing::Values(8, 32 * 2014));
 }  // namespace
 }  // namespace content