Add support for ProxyResolverErrorObserver to ProxyResolverMojo.

net/proxy/proxy_resolver_mojo.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 "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.h"
 #include "net/base/net_errors.h"
 #include "net/dns/mojo_host_resolver_impl.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 "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
 
 namespace net {
 
 class ProxyResolverMojo::Job : public interfaces::ProxyResolverRequestClient,
                                public mojo::ErrorHandler {
  public:
   Job(ProxyResolverMojo* resolver,
       const GURL& url,
@@ skipping 20 matching lines @@
   ProxyResolverMojo* resolver_;
   const GURL url_;
   ProxyInfo* results_;
   net::CompletionCallback callback_;
   LoadState load_state_ = LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 
   base::ThreadChecker thread_checker_;
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 };
 
+class ProxyResolverMojo::ErrorObserverHolder
+    : public interfaces::ProxyResolverErrorObserver {
+ public:
+  ErrorObserverHolder(
+      scoped_ptr<net::ProxyResolverErrorObserver> error_observer);
+
+  // Returns an interfaces::ProxyResolverErrorObserverPtr that can be used to
+  // report errors to the ProxyResolverErrorObserver passed when constructing
+  // |this|. The results of previous calls will no longer able to report errors
+  // when this is called.
+  interfaces::ProxyResolverErrorObserverPtr CreateHandle();
+
+  void OnPacScriptError(int32_t line_number,
+                        const mojo::String& error) override;
+
+ private:
+  scoped_ptr<net::ProxyResolverErrorObserver> error_observer_;
+  mojo::Binding<interfaces::ProxyResolverErrorObserver> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(ErrorObserverHolder);
+};
+
 ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
                             const GURL& url,
                             ProxyInfo* results,
                             const net::CompletionCallback& callback)
     : resolver_(resolver),
       url_(url),
       results_(results),
       callback_(callback),
       binding_(this) {
   binding_.set_error_handler(this);
@@ skipping 37 matching lines @@
   callback_.Reset();
   resolver_->RemoveJob(this);
 }
 
 void ProxyResolverMojo::Job::LoadStateChanged(int32_t load_state) {
   load_state_ = static_cast<LoadState>(load_state);
 }
 
 ProxyResolverMojo::ProxyResolverMojo(
     MojoProxyResolverFactory* mojo_proxy_resolver_factory,
-    HostResolver* host_resolver)
+    HostResolver* host_resolver,
+    scoped_ptr<ProxyResolverErrorObserver> error_observer)
     : ProxyResolver(true /* |expects_pac_bytes| */),
       mojo_proxy_resolver_factory_(mojo_proxy_resolver_factory),
-      host_resolver_(host_resolver) {
+      host_resolver_(host_resolver),
+      error_observer_(new ErrorObserverHolder(error_observer.Pass())) {
 }
 
 ProxyResolverMojo::~ProxyResolverMojo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // All pending requests should have been cancelled.
   DCHECK(pending_jobs_.empty());
   DCHECK(set_pac_script_callback_.IsCancelled());
 }
 
 void ProxyResolverMojo::CancelSetPacScript() {
@@ skipping 43 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   // A Mojo service implementation must outlive its binding.
   mojo_host_resolver_binding_.reset();
 
   interfaces::HostResolverPtr mojo_host_resolver_ptr;
   mojo_host_resolver_.reset(new MojoHostResolverImpl(host_resolver_));
   mojo_host_resolver_binding_.reset(new mojo::Binding<interfaces::HostResolver>(
       mojo_host_resolver_.get(), mojo::GetProxy(&mojo_host_resolver_ptr)));
   mojo_proxy_resolver_ptr_.reset();
   mojo_proxy_resolver_factory_->Create(
-      mojo::GetProxy(&mojo_proxy_resolver_ptr_), mojo_host_resolver_ptr.Pass());
+      mojo::GetProxy(&mojo_proxy_resolver_ptr_), mojo_host_resolver_ptr.Pass(),
+      error_observer_->CreateHandle());
   mojo_proxy_resolver_ptr_.set_error_handler(this);
 }
 
 void ProxyResolverMojo::AbortPendingRequests() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!set_pac_script_callback_.IsCancelled()) {
     set_pac_script_callback_.callback().Run(ERR_PAC_SCRIPT_TERMINATED);
     set_pac_script_callback_.Cancel();
   }
 
@@ skipping 62 matching lines @@
   job->Cancel();
   RemoveJob(job);
 }
 
 LoadState ProxyResolverMojo::GetLoadState(RequestHandle request) const {
   Job* job = static_cast<Job*>(request);
   CHECK_EQ(1u, pending_jobs_.count(job));
   return job->load_state();
 }
 
+ProxyResolverMojo::ErrorObserverHolder::ErrorObserverHolder(
+    scoped_ptr<net::ProxyResolverErrorObserver> error_observer)
+    : error_observer_(error_observer.Pass()), binding_(this) {
+}
+
+interfaces::ProxyResolverErrorObserverPtr
+ProxyResolverMojo::ErrorObserverHolder::CreateHandle() {
+  interfaces::ProxyResolverErrorObserverPtr result;
+  if (error_observer_) {
+    if (binding_.is_bound())
+      binding_.Close();
+    binding_.Bind(mojo::GetProxy(&result));
+  }
+  return result.Pass();
+}
+
+void ProxyResolverMojo::ErrorObserverHolder::OnPacScriptError(
+    int32_t line_number,
+    const mojo::String& error) {
+  DCHECK(error_observer_);
+  error_observer_->OnPACScriptError(line_number, error.To<base::string16>());
+}
+
 }  // namespace net