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/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.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_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 217 matching lines @@
   WakeWaiter();
 }
 
 class TestMojoProxyResolverFactory : public MojoProxyResolverFactory {
  public:
   TestMojoProxyResolverFactory();
   ~TestMojoProxyResolverFactory() override;
 
   // Overridden from MojoProxyResolverFactory:
   void Create(mojo::InterfaceRequest<interfaces::ProxyResolver> req,
-              interfaces::HostResolverPtr host_resolver) override;
+              interfaces::HostResolverPtr host_resolver,
+              interfaces::ProxyResolverErrorObserverPtr error_handler) override;
 
   MockMojoProxyResolver& GetMockResolver() { return *mock_proxy_resolver_; }
 
   void AddFuturePacScriptAction(int creation, SetPacScriptAction action);
   void AddFutureGetProxyAction(int creation, GetProxyForUrlAction action);
 
   int num_create_calls() const { return num_create_calls_; }
   void FailNextCreate() { fail_next_create_ = true; }
 
  private:
   int num_create_calls_;
   std::map<int, std::list<SetPacScriptAction>> pac_script_actions_;
   std::map<int, std::list<GetProxyForUrlAction>> get_proxy_actions_;
   bool fail_next_create_;
 
   scoped_ptr<MockMojoProxyResolver> mock_proxy_resolver_;
 };
 
 TestMojoProxyResolverFactory::TestMojoProxyResolverFactory()
     : num_create_calls_(0), fail_next_create_(false) {
 }
 
 TestMojoProxyResolverFactory::~TestMojoProxyResolverFactory() {
 }
 
 void TestMojoProxyResolverFactory::Create(
     mojo::InterfaceRequest<interfaces::ProxyResolver> req,
-    interfaces::HostResolverPtr host_resolver) {
+    interfaces::HostResolverPtr host_resolver,
+    interfaces::ProxyResolverErrorObserverPtr error_handler) {
   if (fail_next_create_) {
     req = nullptr;
     fail_next_create_ = false;
   } else {
     mock_proxy_resolver_.reset(new MockMojoProxyResolver(req.Pass()));
 
     for (const auto& action : pac_script_actions_[num_create_calls_])
       mock_proxy_resolver_->AddPacScriptAction(action);
 
     for (const auto& action : get_proxy_actions_[num_create_calls_])
@@ skipping 54 matching lines @@
   error_ = callback_.WaitForResult();
   return error_;
 }
 
 }  // namespace
 
 class ProxyResolverMojoTest : public testing::Test {
  public:
   void SetUp() override {
     proxy_resolver_mojo_.reset(new ProxyResolverMojo(
-        &mojo_proxy_resolver_factory_, &mock_host_resolver_));
+        &mojo_proxy_resolver_factory_, &mock_host_resolver_, nullptr));
   }
 
   scoped_ptr<Request> MakeRequest(const GURL& url) {
     return make_scoped_ptr(new Request(proxy_resolver_mojo_.get(), url));
   }
 
   mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString(
       const std::string& pac_string) {
     ProxyInfo proxy_info;
     proxy_info.UsePacString(pac_string);
@@ skipping 350 matching lines @@
   // resolve request.
   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
   EXPECT_EQ("DIRECT", request->results().ToPacString());
 
   EXPECT_EQ(2, mojo_proxy_resolver_factory_.num_create_calls());
 }
 
 }  // namespace net