chromeos: Avoid DCHECK in ProxyResolutionServiceProvider.

chromeos/dbus/services/proxy_resolution_service_provider.cc

 // Copyright (c) 2012 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 "chromeos/dbus/services/proxy_resolution_service_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 145 matching lines @@
 
   // If signal information was supplied, emit a signal instead of including
   // proxy information in the response.
   std::unique_ptr<Request> request =
       !signal_interface.empty()
           ? base::MakeUnique<Request>(source_url, signal_interface, signal_name,
                                       context_getter)
           : base::MakeUnique<Request>(source_url, std::move(response),
                                       response_sender, context_getter);
 
+  NotifyCallback notify_callback =
+      base::Bind(&ProxyResolutionServiceProvider::NotifyProxyResolved,
+                 weak_ptr_factory_.GetWeakPtr());
+
   // This would ideally call PostTaskAndReply() instead of PostTask(), but
   // ResolveProxyOnNetworkThread()'s call to net::ProxyService::ResolveProxy()
   // can result in an asynchronous lookup, in which case the result won't be
   // available immediately.
   context_getter->GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyResolutionServiceProvider::ResolveProxyOnNetworkThread,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request))));
+                 base::Passed(std::move(request)), origin_thread_,
+                 notify_callback));
 
   // If we didn't already pass the response to the Request object because we're
   // returning data via a signal, send an empty response immediately.
   if (response)
     response_sender.Run(std::move(response));
 }
 
+// static
 void ProxyResolutionServiceProvider::ResolveProxyOnNetworkThread(
-    std::unique_ptr<Request> request) {
+    std::unique_ptr<Request> request,
+    scoped_refptr<base::SingleThreadTaskRunner> notify_thread,
+    NotifyCallback notify_callback) {
   DCHECK(request->context_getter->GetNetworkTaskRunner()
              ->BelongsToCurrentThread());
 
   net::ProxyService* proxy_service =
       request->context_getter->GetURLRequestContext()->proxy_service();
   if (!proxy_service) {
     request->error = "No proxy service in chrome";
-    OnResolutionComplete(std::move(request), net::ERR_UNEXPECTED);
+    OnResolutionComplete(std::move(request), notify_thread, notify_callback,
+                         net::ERR_UNEXPECTED);
     return;
   }
 
   Request* request_ptr = request.get();
   net::CompletionCallback callback = base::Bind(
       &ProxyResolutionServiceProvider::OnResolutionComplete,
-      weak_ptr_factory_.GetWeakPtr(), base::Passed(std::move(request)));
+      base::Passed(std::move(request)), notify_thread, notify_callback);

[James Cook, 2017/04/03 15:30:23]

optional: Add a comment near here (or in header?) saying we can't use
GetWeakPtr() here and that's the reason these methods are static?

[Daniel Erat, 2017/04/04 00:01:37]

Done.

 
   VLOG(1) << "Starting network proxy resolution for "
           << request_ptr->source_url;
   const int result = proxy_service->ResolveProxy(
       GURL(request_ptr->source_url), std::string(), &request_ptr->proxy_info,
       callback, nullptr, nullptr, net::NetLogWithSource());
   if (result != net::ERR_IO_PENDING) {
     VLOG(1) << "Network proxy resolution completed synchronously.";
     callback.Run(result);
   }
 }
 
+// static
 void ProxyResolutionServiceProvider::OnResolutionComplete(
     std::unique_ptr<Request> request,
+    scoped_refptr<base::SingleThreadTaskRunner> notify_thread,
+    NotifyCallback notify_callback,
     int result) {
   DCHECK(request->context_getter->GetNetworkTaskRunner()
              ->BelongsToCurrentThread());
 
   if (request->error.empty() && result != net::OK)
     request->error = net::ErrorToString(result);
 
-  origin_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&ProxyResolutionServiceProvider::NotifyProxyResolved,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request))));
+  notify_thread->PostTask(
+      FROM_HERE, base::Bind(notify_callback, base::Passed(std::move(request))));
 }
 
 void ProxyResolutionServiceProvider::NotifyProxyResolved(
     std::unique_ptr<Request> request) {
   DCHECK(OnOriginThread());
 
   if (request->response) {
     // Reply to the original D-Bus method call.
     dbus::MessageWriter writer(request->response.get());
     writer.AppendString(request->proxy_info.ToPacString());
     writer.AppendString(request->error);
     request->response_sender.Run(std::move(request->response));
   } else {
     // Send a signal to the client.
     dbus::Signal signal(request->signal_interface, request->signal_name);
     dbus::MessageWriter writer(&signal);
     writer.AppendString(request->source_url);
     writer.AppendString(request->proxy_info.ToPacString());
     writer.AppendString(request->error);
     exported_object_->SendSignal(&signal);
     VLOG(1) << "Sending signal: " << signal.ToString();
   }
 }
 
 }  // namespace chromeos