Pass error messages from native messaging to web-app.

remoting/host/setup/me2me_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/me2me_native_messaging_host.h"
+#include <sstream>

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

don't need this include.
nit: add an empty line here.

 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 84 matching lines @@
   DCHECK(!quit_closure.is_null());
 
   quit_closure_ = quit_closure;
 
   channel_->Start(this);
 }
 
 void Me2MeNativeMessagingHost::OnMessage(scoped_ptr<base::Value> message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+
   if (!message->IsType(base::Value::TYPE_DICTIONARY)) {
-    LOG(ERROR) << "Received a message that's not a dictionary.";
-    channel_->SendMessage(nullptr);
+    std::string error_message = "Received a message that's not a dictionary.";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
 
   scoped_ptr<base::DictionaryValue> message_dict(
       static_cast<base::DictionaryValue*>(message.release()));
-  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  std::string type;
+  if (!message_dict->GetString("type", &type)) {
+    std::string error_message = "'type' not found";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
+    return;
+  }
+
+  // Message response types are just the message type with "Response" appended.
+  response->SetString("type", type + "Response");
 
   // If the client supplies an ID, it will expect it in the response. This
   // might be a string or a number, so cope with both.
   const base::Value* id;
   if (message_dict->Get("id", &id))
     response->Set("id", id->DeepCopy());
 
-  std::string type;
-  if (!message_dict->GetString("type", &type)) {
-    LOG(ERROR) << "'type' not found";
-    channel_->SendMessage(nullptr);
-    return;
-  }
-
-  response->SetString("type", type + "Response");
-
   if (type == "hello") {
     ProcessHello(message_dict.Pass(), response.Pass());
   } else if (type == "clearPairedClients") {
     ProcessClearPairedClients(message_dict.Pass(), response.Pass());
   } else if (type == "deletePairedClient") {
     ProcessDeletePairedClient(message_dict.Pass(), response.Pass());
   } else if (type == "getHostName") {
     ProcessGetHostName(message_dict.Pass(), response.Pass());
   } else if (type == "getPinHash") {
     ProcessGetPinHash(message_dict.Pass(), response.Pass());
@@ skipping 15 matching lines @@
     ProcessGetDaemonState(message_dict.Pass(), response.Pass());
   } else if (type == "getHostClientId") {
     ProcessGetHostClientId(message_dict.Pass(), response.Pass());
   } else if (type == "getCredentialsFromAuthCode") {
     ProcessGetCredentialsFromAuthCode(
         message_dict.Pass(), response.Pass(), true);
   } else if (type == "getRefreshTokenFromAuthCode") {
     ProcessGetCredentialsFromAuthCode(
         message_dict.Pass(), response.Pass(), false);
   } else {
-    LOG(ERROR) << "Unsupported request type: " << type;
-    OnError();
+    std::string error_message = "Unsupported request type: " + type;
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
   }
 }
 
 void Me2MeNativeMessagingHost::OnDisconnect() {
   if (!quit_closure_.is_null())
     base::ResetAndReturn(&quit_closure_).Run();
 }
 
 void Me2MeNativeMessagingHost::ProcessHello(
     scoped_ptr<base::DictionaryValue> message,
@@ skipping 35 matching lines @@
 
   if (needs_elevation_) {
     if (!DelegateToElevatedHost(message.Pass()))
       SendBooleanResult(response.Pass(), false);
     return;
   }
 
   std::string client_id;
   if (!message->GetString(protocol::PairingRegistry::kClientIdKey,
                           &client_id)) {
-    LOG(ERROR) << "'" << protocol::PairingRegistry::kClientIdKey
-               << "' string not found.";
-    OnError();
+    std::string error_message = std::string("'") +
+        protocol::PairingRegistry::kClientIdKey + "' string not found";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
 
   if (pairing_registry_.get()) {
     pairing_registry_->DeletePairing(
         client_id, base::Bind(&Me2MeNativeMessagingHost::SendBooleanResult,
                               weak_ptr_, base::Passed(&response)));
   } else {
     SendBooleanResult(response.Pass(), false);
   }
 }
 
 void Me2MeNativeMessagingHost::ProcessGetHostName(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetString("hostname", net::GetHostName());
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGetPinHash(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string host_id;
   if (!message->GetString("hostId", &host_id)) {
-    LOG(ERROR) << "'hostId' not found: " << message;
-    OnError();
+    std::string error_message = "'hostId' not found";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
   std::string pin;
   if (!message->GetString("pin", &pin)) {
-    LOG(ERROR) << "'pin' not found: " << message;
-    OnError();
+    std::string error_message = "'pin' not found";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
   response->SetString("hash", MakeHostPinHash(host_id, pin));
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGenerateKeyPair(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::Generate();
   response->SetString("privateKey", key_pair->ToString());
   response->SetString("publicKey", key_pair->GetPublicKey());
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessUpdateDaemonConfig(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(message.Pass()))
-      SendAsyncResult(response.Pass(), DaemonController::RESULT_FAILED);
+    if (!DelegateToElevatedHost(message.Pass())) {
+      std::string error_message = "DelegateToElevatedHost failed";
+      LOG(ERROR) << error_message;
+      SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
+    }
     return;
   }
 
   scoped_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(message.Pass());
   if (!config_dict) {
-    OnError();
+    std::string error_message = "No config dictionary in message";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
 
+  scoped_ptr<base::DictionaryValue> response_copy(response->CreateDeepCopy());
   daemon_controller_->UpdateConfig(
       config_dict.Pass(),
-      base::Bind(&Me2MeNativeMessagingHost::SendAsyncResult, weak_ptr_,
-                 base::Passed(&response)));
+      base::Bind(&Me2MeNativeMessagingHost::SendAsyncSuccess, weak_ptr_,
+                 base::Passed(&response)),
+      base::Bind(&Me2MeNativeMessagingHost::SendAsyncFailure, weak_ptr_,
+                 base::Passed(&response_copy)));
 }
 
 void Me2MeNativeMessagingHost::ProcessGetDaemonConfig(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   daemon_controller_->GetConfig(
       base::Bind(&Me2MeNativeMessagingHost::SendConfigResponse, weak_ptr_,
                  base::Passed(&response)));
@@ skipping 23 matching lines @@
       base::Bind(&Me2MeNativeMessagingHost::SendUsageStatsConsentResponse,
                  weak_ptr_, base::Passed(&response)));
 }
 
 void Me2MeNativeMessagingHost::ProcessStartDaemon(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(message.Pass()))
-      SendAsyncResult(response.Pass(), DaemonController::RESULT_FAILED);
+    if (!DelegateToElevatedHost(message.Pass())) {
+      std::string error_message = "DelegateToElevatedHost failed";
+      LOG(ERROR) << error_message;
+      SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
+    }
     return;
   }
 
   bool consent;
   if (!message->GetBoolean("consent", &consent)) {
-    LOG(ERROR) << "'consent' not found.";
-    OnError();
+    std::string error_message = "'consent' not found";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
 
   scoped_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(message.Pass());
   if (!config_dict) {
-    OnError();
+    std::string error_message = "No config dictionary in message";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
 
+  scoped_ptr<base::DictionaryValue> response_copy(response->CreateDeepCopy());
   daemon_controller_->SetConfigAndStart(
       config_dict.Pass(), consent,
-      base::Bind(&Me2MeNativeMessagingHost::SendAsyncResult, weak_ptr_,
-                 base::Passed(&response)));
+      base::Bind(&Me2MeNativeMessagingHost::SendAsyncSuccess, weak_ptr_,
+                 base::Passed(&response)),
+      base::Bind(&Me2MeNativeMessagingHost::SendAsyncFailure, weak_ptr_,
+                 base::Passed(&response_copy)));
 }
 
 void Me2MeNativeMessagingHost::ProcessStopDaemon(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(message.Pass()))
-      SendAsyncResult(response.Pass(), DaemonController::RESULT_FAILED);
+    if (!DelegateToElevatedHost(message.Pass())) {
+      std::string error_message = "DelegateToElevatedHost failed";
+      LOG(ERROR) << error_message;
+      SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
+    }
     return;
   }
 
+  scoped_ptr<base::DictionaryValue> response_copy(response->CreateDeepCopy());
   daemon_controller_->Stop(
-      base::Bind(&Me2MeNativeMessagingHost::SendAsyncResult, weak_ptr_,
-                 base::Passed(&response)));
+      base::Bind(&Me2MeNativeMessagingHost::SendAsyncSuccess, weak_ptr_,
+                 base::Passed(&response)),
+      base::Bind(&Me2MeNativeMessagingHost::SendAsyncFailure, weak_ptr_,
+                 base::Passed(&response_copy)));
 }
 
 void Me2MeNativeMessagingHost::ProcessGetDaemonState(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DaemonController::State state = daemon_controller_->GetState();
   switch (state) {
     case DaemonController::STATE_NOT_IMPLEMENTED:
@@ skipping 29 matching lines @@
 }
 
 void Me2MeNativeMessagingHost::ProcessGetCredentialsFromAuthCode(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response,
     bool need_user_email) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string auth_code;
   if (!message->GetString("authorizationCode", &auth_code)) {
-    LOG(ERROR) << "'authorizationCode' string not found.";
-    OnError();
+    std::string error_message = "'authorizationCode' string not found";
+    LOG(ERROR) << error_message;
+    SendAsyncFailure(response.Pass(), error_message, FROM_HERE);
     return;
   }
 
   gaia::OAuthClientInfo oauth_client_info = {
     google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING_HOST),
     google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING_HOST),
     kServiceAccountRedirectUri
   };
 
   oauth_client_->GetCredentialsFromAuthCode(
@@ skipping 28 matching lines @@
     scoped_ptr<base::DictionaryValue> response,
     const DaemonController::UsageStatsConsent& consent) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetBoolean("supported", consent.supported);
   response->SetBoolean("allowed", consent.allowed);
   response->SetBoolean("setByPolicy", consent.set_by_policy);
   channel_->SendMessage(response.Pass());
 }
 
-void Me2MeNativeMessagingHost::SendAsyncResult(
-    scoped_ptr<base::DictionaryValue> response,
-    DaemonController::AsyncResult result) {
+void Me2MeNativeMessagingHost::SendAsyncSuccess(
+    scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (result) {
-    case DaemonController::RESULT_OK:
-      response->SetString("result", "OK");
-      break;
-    case DaemonController::RESULT_FAILED:
-      response->SetString("result", "FAILED");
-      break;
-    case DaemonController::RESULT_CANCELLED:
-      response->SetString("result", "CANCELLED");

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

Do we still send "CANCELLED" response? I think it was useful when user
explicitly cancels an operation, e.g. UAC prompt. In that case we don't want to
show the error in the webapp?

[Jamie, 2015/08/11 21:23:13]

I've reverted this change, but FWIW I don't think it's currently sent (see
https://code.google.com/p/chromium/codesearch#chromium/src/remoting/host/setu...)

-      break;
-    case DaemonController::RESULT_FAILED_DIRECTORY:
-      response->SetString("result", "FAILED_DIRECTORY");
-      break;
-  }
+  response->SetString("result", "OK");
   channel_->SendMessage(response.Pass());
 }
 
+void Me2MeNativeMessagingHost::SendAsyncFailure(
+    scoped_ptr<base::DictionaryValue> response,
+    const std::string& error_message,
+    const tracked_objects::Location& location) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  response->SetString("result", "FAILED");
+  response->SetString("error_message", error_message);
+  response->SetString("error_location", location.ToString());
+  channel_->SendMessage(response.Pass());
+}
+
 void Me2MeNativeMessagingHost::SendBooleanResult(
     scoped_ptr<base::DictionaryValue> response, bool result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetBoolean("result", result);
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendCredentialsResponse(
     scoped_ptr<base::DictionaryValue> response,
     const std::string& user_email,
     const std::string& refresh_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!user_email.empty()) {
     response->SetString("userEmail", user_email);
   }
   response->SetString("refreshToken", refresh_token);
   channel_->SendMessage(response.Pass());
 }
 
-void Me2MeNativeMessagingHost::OnError() {
-  // Trigger a host shutdown by sending a nullptr message.
-  channel_->SendMessage(nullptr);
-}
-
 void Me2MeNativeMessagingHost::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!quit_closure_.is_null())
     base::ResetAndReturn(&quit_closure_).Run();
 }
 
 #if defined(OS_WIN)
 Me2MeNativeMessagingHost::ElevatedChannelEventHandler::
     ElevatedChannelEventHandler(Me2MeNativeMessagingHost* host)
@@ skipping 191 matching lines @@
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     scoped_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting