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:
+  class Waiter final : public base::RefCounted<Waiter> {
+   public:
+    Waiter() = default;
+    void Signal(mojom::URLLoaderAssociatedRequest loader_request,
+                mojom::URLLoaderClientAssociatedPtrInfo client_ptr) {
+      loader_request_ = std::move(loader_request);
+      client_ptr_ = std::move(client_ptr);
+      run_loop_.Quit();
+    }
+    std::pair<mojom::URLLoaderAssociatedRequest,
+              mojom::URLLoaderClientAssociatedPtrInfo>
+    Wait() {
+      run_loop_.Run();
+      return std::make_pair(std::move(loader_request_), std::move(client_ptr_));
+    }
+
+   private:
+    friend class base::RefCounted<Waiter>;
+    ~Waiter() {}
+
+    base::RunLoop run_loop_;
+    mojom::URLLoaderAssociatedRequest loader_request_;
+    mojom::URLLoaderClientAssociatedPtrInfo client_ptr_;
+
+    DISALLOW_COPY_AND_ASSIGN(Waiter);
+  };
+
+  explicit TestURLLoaderFactory(scoped_refptr<Waiter> waiter)
+      : waiter_(waiter) {}
+  ~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 {
+    waiter_->Signal(std::move(request), 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:
+  scoped_refptr<Waiter> waiter_;
+
+  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;
+    scoped_refptr<TestURLLoaderFactory::Waiter> waiter(

[yzshen1, 2016/11/09 17:40:48]

I think |waiter| may not be necessary, we could:
- keep a pointer to the TestURLLoaderFactory instance, say, factory_impl. You
could use the returned value of MakeStrongBinding(), or make a non-strong
binding and manage the instance lifetime yourself.
- after you call url_loader_factory_->CreateLoaderAndStart(), call
url_loader_factory_.FlushForTesting(), that will make sure the previous call
arrives at the other side.
- let TestURLLoaderFactory::CreateLoaderAndStart() store the incoming request
and ptr_info.
- get the request and ptr from factory_impl.

[yhirano, 2016/11/10 07:33:53]

Thanks, done.

+        new TestURLLoaderFactory::Waiter());
+    mojo::MakeStrongBinding(base::MakeUnique<TestURLLoaderFactory>(waiter),
+                            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()));
+
+    auto pair = waiter->Wait();
+
     mojom::URLLoaderClientAssociatedPtr client_ptr;
-    client_ptr.Bind(std::move(client_ptr_info));
+    client_ptr.Bind(std::move(pair.second));
     handler_.reset(new MojoAsyncResourceHandlerWithCustomDataPipeOperations(
-        request_.get(), &rdh_, nullptr, std::move(client_ptr)));
+        request_.get(), &rdh_, std::move(pair.first), 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