Pass error messages from native messaging to web-app.

remoting/host/setup/daemon_controller.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/daemon_controller.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 32 matching lines @@
   DaemonController::GetConfigCallback wrapped_done = base::Bind(
       &DaemonController::InvokeConfigCallbackAndScheduleNext, this, done);
   base::Closure request = base::Bind(
       &DaemonController::DoGetConfig, this, wrapped_done);
   ServiceOrQueueRequest(request);
 }
 
 void DaemonController::SetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
     bool consent,
-    const CompletionCallback& done) {
+    const base::Closure& on_done,
+    const ErrorCallback& on_error) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  DaemonController::CompletionCallback wrapped_done = base::Bind(
-      &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
+  base::Closure wrapped_on_done = base::Bind(
+      &DaemonController::InvokeSuccessCallbackAndScheduleNext, this, on_done);
+  DaemonController::ErrorCallback wrapped_on_error = base::Bind(
+      &DaemonController::InvokeErrorCallbackAndScheduleNext, this, on_error);

[Sergey Ulanov, 2015/08/08 00:57:09]

Do we need separate on_done and on_error cases? I think this code would be
simpler if there was only one completion callback. If you are concerned about
passing error message when there is no error, then maybe add a class for the
result with an optional error field? I.e. make AsyncResult a class or struct
instead of enum.

   base::Closure request = base::Bind(
       &DaemonController::DoSetConfigAndStart, this, base::Passed(&config),
-      consent, wrapped_done);
+      consent, wrapped_on_done, wrapped_on_error);
   ServiceOrQueueRequest(request);
 }
 
 void DaemonController::UpdateConfig(scoped_ptr<base::DictionaryValue> config,
-                                    const CompletionCallback& done) {
+                                    const base::Closure& on_done,
+                                    const ErrorCallback& on_error) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  DaemonController::CompletionCallback wrapped_done = base::Bind(
-      &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
+  base::Closure wrapped_on_done = base::Bind(
+      &DaemonController::InvokeSuccessCallbackAndScheduleNext, this, on_done);
+  DaemonController::ErrorCallback wrapped_on_error = base::Bind(
+      &DaemonController::InvokeErrorCallbackAndScheduleNext, this, on_error);
   base::Closure request = base::Bind(
       &DaemonController::DoUpdateConfig, this, base::Passed(&config),
-      wrapped_done);
+      wrapped_on_done, wrapped_on_error);
   ServiceOrQueueRequest(request);
 }
 
-void DaemonController::Stop(const CompletionCallback& done) {
+void DaemonController::Stop(const base::Closure& on_done,
+                            const ErrorCallback& on_error) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  DaemonController::CompletionCallback wrapped_done = base::Bind(
-      &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
+  base::Closure wrapped_on_done = base::Bind(
+      &DaemonController::InvokeSuccessCallbackAndScheduleNext, this, on_done);
+  DaemonController::ErrorCallback wrapped_on_error = base::Bind(
+      &DaemonController::InvokeErrorCallbackAndScheduleNext, this, on_error);
   base::Closure request = base::Bind(
-      &DaemonController::DoStop, this, wrapped_done);
+      &DaemonController::DoStop, this, wrapped_on_done, wrapped_on_error);
   ServiceOrQueueRequest(request);
 }
 
 void DaemonController::GetUsageStatsConsent(
     const GetUsageStatsConsentCallback& done) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   DaemonController::GetUsageStatsConsentCallback wrapped_done = base::Bind(
       &DaemonController::InvokeConsentCallbackAndScheduleNext, this, done);
   base::Closure request = base::Bind(
@@ skipping 14 matching lines @@
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<base::DictionaryValue> config = delegate_->GetConfig();
   caller_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(done, base::Passed(&config)));
 }
 
 void DaemonController::DoSetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
     bool consent,
-    const CompletionCallback& done) {
+    const base::Closure& on_done,
+    const ErrorCallback& on_error) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  delegate_->SetConfigAndStart(config.Pass(), consent, done);
+  delegate_->SetConfigAndStart(config.Pass(), consent, on_done, on_error);
 }
 
 void DaemonController::DoUpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done) {
+    const base::Closure& on_done,
+    const ErrorCallback& on_error) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  delegate_->UpdateConfig(config.Pass(), done);
+  delegate_->UpdateConfig(config.Pass(), on_done, on_error);
 }
 
-void DaemonController::DoStop(const CompletionCallback& done) {
+void DaemonController::DoStop(const base::Closure& on_done,
+    const ErrorCallback& on_error) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  delegate_->Stop(done);
+  delegate_->Stop(on_done, on_error);
 }
 
 void DaemonController::DoGetUsageStatsConsent(
     const GetUsageStatsConsentCallback& done) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   DaemonController::UsageStatsConsent consent =
       delegate_->GetUsageStatsConsent();
   caller_task_runner_->PostTask(FROM_HERE, base::Bind(done, consent));
 }
 
-void DaemonController::InvokeCompletionCallbackAndScheduleNext(
-    const CompletionCallback& done,
-    AsyncResult result) {
+void DaemonController::InvokeSuccessCallbackAndScheduleNext(
+    const base::Closure& callback) {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&DaemonController::InvokeCompletionCallbackAndScheduleNext,
-                   this, done, result));
+        base::Bind(&DaemonController::InvokeSuccessCallbackAndScheduleNext,
+                   this, callback));
     return;
   }
 
-  done.Run(result);
+  callback.Run();
+  ScheduleNext();
+}
+
+void DaemonController::InvokeErrorCallbackAndScheduleNext(
+    const ErrorCallback& callback,
+    const std::string& error_message,
+    const tracked_objects::Location& location) {
+  if (!caller_task_runner_->BelongsToCurrentThread()) {

[Sergey Ulanov, 2015/08/08 00:57:09]

Delegate interface definition says that the callback must be called on the
original thread, so I'm not sure this is necessary.

+    caller_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&DaemonController::InvokeErrorCallbackAndScheduleNext,
+                   this, callback, error_message, location));
+    return;
+  }
+
+  callback.Run(error_message, location);
   ScheduleNext();
 }
 
 void DaemonController::InvokeConfigCallbackAndScheduleNext(
-    const GetConfigCallback& done,
+    const GetConfigCallback& callback,
     scoped_ptr<base::DictionaryValue> config) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  done.Run(config.Pass());
+  callback.Run(config.Pass());
   ScheduleNext();
 }
 
 void DaemonController::InvokeConsentCallbackAndScheduleNext(
-    const GetUsageStatsConsentCallback& done,
+    const GetUsageStatsConsentCallback& callback,
     const UsageStatsConsent& consent) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  done.Run(consent);
+  callback.Run(consent);
   ScheduleNext();
 }
 
 void DaemonController::ScheduleNext() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   pending_requests_.pop();
   ServiceNextRequest();
 }
 
 void DaemonController::ServiceOrQueueRequest(const base::Closure& request) {
   bool servicing_request = !pending_requests_.empty();
   pending_requests_.push(request);
   if (!servicing_request)
     ServiceNextRequest();
 }
 
 void DaemonController::ServiceNextRequest() {
   if (!pending_requests_.empty())
     delegate_task_runner_->PostTask(FROM_HERE, pending_requests_.front());
 }
 
 }  // namespace remoting