Add support for ProxyResolverErrorObserver to ProxyResolverMojo.

net/proxy/proxy_resolver_mojo_unittest.cc

 // Copyright 2015 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 "net/proxy/proxy_resolver_mojo.h"
 
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
+#include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_resolver.h"
+#include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/proxy/proxy_resolver_script_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 275 matching lines @@
   void WaitForNextRequest();
 
   void ClearBlockedClients();
 
  private:
   // Overridden from interfaces::ProxyResolver:
   void CreateResolver(
       const mojo::String& pac_url,
       mojo::InterfaceRequest<interfaces::ProxyResolver> request,
       interfaces::HostResolverPtr host_resolver,
+      interfaces::ProxyResolverErrorObserverPtr error_observer,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override;
 
   void WakeWaiter();
 
   MockMojoProxyResolver* resolver_;
   std::queue<CreateProxyResolverAction> create_resolver_actions_;
 
   base::Closure quit_closure_;
 
   ScopedVector<interfaces::ProxyResolverFactoryRequestClientPtr>
@@ skipping 32 matching lines @@
 }
 
 void MockMojoProxyResolverFactory::ClearBlockedClients() {
   blocked_clients_.clear();
 }
 
 void MockMojoProxyResolverFactory::CreateResolver(
     const mojo::String& pac_script,
     mojo::InterfaceRequest<interfaces::ProxyResolver> request,
     interfaces::HostResolverPtr host_resolver,
+    interfaces::ProxyResolverErrorObserverPtr error_observer,
     interfaces::ProxyResolverFactoryRequestClientPtr client) {
   ASSERT_FALSE(create_resolver_actions_.empty());
   CreateProxyResolverAction action = create_resolver_actions_.front();
   create_resolver_actions_.pop();
 
   EXPECT_EQ(action.expected_pac_script, pac_script.To<std::string>());
   switch (action.action) {
     case CreateProxyResolverAction::COMPLETE:
       if (action.error == OK)
         resolver_->AddConnection(request.Pass());
@@ skipping 21 matching lines @@
 }
 
 }  // namespace
 
 class ProxyResolverMojoTest : public testing::Test,
                               public MojoProxyResolverFactory {
  public:
   void SetUp() override {
     mock_proxy_resolver_factory_.reset(new MockMojoProxyResolverFactory(
         &mock_proxy_resolver_, mojo::GetProxy(&factory_ptr_)));
-    proxy_resolver_factory_mojo_.reset(
-        new ProxyResolverFactoryMojo(this, nullptr));
+    proxy_resolver_factory_mojo_.reset(new ProxyResolverFactoryMojo(
+        this, nullptr,
+        base::Callback<scoped_ptr<ProxyResolverErrorObserver>()>()));
   }
 
   scoped_ptr<Request> MakeRequest(const GURL& url) {
     return make_scoped_ptr(new Request(proxy_resolver_mojo_.get(), url));
   }
 
   scoped_ptr<base::ScopedClosureRunner> CreateResolver(
       const mojo::String& pac_script,
       mojo::InterfaceRequest<interfaces::ProxyResolver> req,
       interfaces::HostResolverPtr host_resolver,
+      interfaces::ProxyResolverErrorObserverPtr error_observer,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override {
     factory_ptr_->CreateResolver(pac_script, req.Pass(), host_resolver.Pass(),
-                                 client.Pass());
+                                 error_observer.Pass(), client.Pass());
     return make_scoped_ptr(
         new base::ScopedClosureRunner(on_delete_callback_.closure()));
   }
 
   mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString(
       const std::string& pac_string) {
     ProxyInfo proxy_info;
     proxy_info.UsePacString(pac_string);
 
     return mojo::Array<interfaces::ProxyServerPtr>::From(
@@ skipping 294 matching lines @@
                 &handle, net_log)));
   on_delete_callback_.WaitForResult();
 }
 
 TEST_F(ProxyResolverMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net