Refactor the daemon controller so that the callbacks are called on the caller thread.

remoting/host/setup/native_messaging_host.cc

 // Copyright 2013 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 "remoting/host/setup/native_messaging_host.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 44 matching lines @@
     LOG(ERROR) << "'config' dictionary not found";
   }
   return result.Pass();
 }
 
 }  // namespace
 
 namespace remoting {
 
 NativeMessagingHost::NativeMessagingHost(
-    scoped_ptr<DaemonController> daemon_controller,
+    scoped_refptr<DaemonController> daemon_controller,
     scoped_refptr<protocol::PairingRegistry> pairing_registry,
     scoped_ptr<OAuthClient> oauth_client,
     base::PlatformFile input,
     base::PlatformFile output,
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     const base::Closure& quit_closure)
     : caller_task_runner_(caller_task_runner),
       quit_closure_(quit_closure),
       native_messaging_reader_(input),
       native_messaging_writer_(output),
-      daemon_controller_(daemon_controller.Pass()),
+      daemon_controller_(daemon_controller),
       pairing_registry_(pairing_registry),
       oauth_client_(oauth_client.Pass()),
       pending_requests_(0),
       shutdown_(false),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
 }
 
 NativeMessagingHost::~NativeMessagingHost() {}
 
@@ skipping 176 matching lines @@
 }
 
 bool NativeMessagingHost::ProcessUpdateDaemonConfig(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   scoped_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(message);
   if (!config_dict)
     return false;
 
-  // base::Unretained() is safe because this object owns |daemon_controller_|
-  // which owns the thread that will run the callback.
   daemon_controller_->UpdateConfig(
       config_dict.Pass(),
-      base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
+      base::Bind(&NativeMessagingHost::SendAsyncResult, weak_ptr_,
                  base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetDaemonConfig(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   daemon_controller_->GetConfig(
-      base::Bind(&NativeMessagingHost::SendConfigResponse,
-                 base::Unretained(this), base::Passed(&response)));
+      base::Bind(&NativeMessagingHost::SendConfigResponse, weak_ptr_,
+                 base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetPairedClients(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   if (pairing_registry_) {
     pairing_registry_->GetAllPairings(
         base::Bind(&NativeMessagingHost::SendPairedClientsResponse, weak_ptr_,
                    base::Passed(&response)));
   } else {
     scoped_ptr<base::ListValue> no_paired_clients(new base::ListValue);
     SendPairedClientsResponse(response.Pass(), no_paired_clients.Pass());
   }
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetUsageStatsConsent(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   daemon_controller_->GetUsageStatsConsent(
       base::Bind(&NativeMessagingHost::SendUsageStatsConsentResponse,
-                 base::Unretained(this), base::Passed(&response)));
+                 weak_ptr_, base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessStartDaemon(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   bool consent;
   if (!message.GetBoolean("consent", &consent)) {
     LOG(ERROR) << "'consent' not found.";
     return false;
   }
 
   scoped_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(message);
   if (!config_dict)
     return false;
 
   daemon_controller_->SetConfigAndStart(
       config_dict.Pass(), consent,
-      base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
+      base::Bind(&NativeMessagingHost::SendAsyncResult, weak_ptr_,
                  base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessStopDaemon(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   daemon_controller_->Stop(
-      base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
+      base::Bind(&NativeMessagingHost::SendAsyncResult, weak_ptr_,
                  base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetDaemonState(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   DaemonController::State state = daemon_controller_->GetState();
   switch (state) {
     case DaemonController::STATE_NOT_IMPLEMENTED:
@@ skipping 89 matching lines @@
 
 void NativeMessagingHost::SendPairedClientsResponse(
     scoped_ptr<base::DictionaryValue> response,
     scoped_ptr<base::ListValue> pairings) {
   response->Set("pairedClients", pairings.release());
   SendResponse(response.Pass());
 }
 
 void NativeMessagingHost::SendUsageStatsConsentResponse(
     scoped_ptr<base::DictionaryValue> response,
-    bool supported,
-    bool allowed,
-    bool set_by_policy) {
-  response->SetBoolean("supported", supported);
-  response->SetBoolean("allowed", allowed);
-  response->SetBoolean("setByPolicy", set_by_policy);
+    const DaemonController::UsageStatsConsent& consent) {
+  response->SetBoolean("supported", consent.supported);
+  response->SetBoolean("allowed", consent.allowed);
+  response->SetBoolean("setByPolicy", consent.set_by_policy);
   SendResponse(response.Pass());
 }
 
 void NativeMessagingHost::SendAsyncResult(
     scoped_ptr<base::DictionaryValue> response,
     DaemonController::AsyncResult result) {
   switch (result) {
     case DaemonController::RESULT_OK:
       response->SetString("result", "OK");
       break;
@@ skipping 53 matching lines @@
                                      oauth_client.Pass(),
                                      read_file, write_file,
                                      message_loop.message_loop_proxy(),
                                      run_loop.QuitClosure());
   host.Start();
   run_loop.Run();
   return kSuccessExitCode;
 }
 
 }  // namespace remoting