Send enums as strings between Chromoting Native Messaging host and web-app.

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/bind.h"
 #include "base/callback.h"
@@ skipping 18 matching lines @@
   } else {
     LOG(ERROR) << "'config' dictionary not found";
   }
   return result.Pass();
 }
 
 }  // namespace
 
 namespace remoting {
 
+const char NativeMessagingHost::kStateNotImplemented[] = "NOT_IMPLEMENTED";

[Sergey Ulanov, 2013/05/31 23:01:43]

As I mentioned before you don't really need to define these consts - each of
them is used only in one place, so you are not gaining anything. Just put the
string values in ProcessGetDaemonState().

[Lambros, 2013/06/03 21:28:44]

Done.

+const char NativeMessagingHost::kStateNotInstalled[] = "NOT_INSTALLED";
+const char NativeMessagingHost::kStateInstalling[] = "INSTALLING";
+const char NativeMessagingHost::kStateStopped[] = "STOPPED";
+const char NativeMessagingHost::kStateStarting[] = "STARTING";
+const char NativeMessagingHost::kStateStarted[] = "STARTED";
+const char NativeMessagingHost::kStateStopping[] = "STOPPING";
+const char NativeMessagingHost::kStateUnknown[] = "UNKNOWN";
+
+const char NativeMessagingHost::kResultOk[] = "OK";
+const char NativeMessagingHost::kResultFailed[] = "FAILED";
+const char NativeMessagingHost::kResultCancelled[] = "CANCELLED";
+const char NativeMessagingHost::kResultFailedDirectory[] = "FAILED_DIRECTORY";
+
 NativeMessagingHost::NativeMessagingHost(
     scoped_ptr<DaemonController> daemon_controller,
     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),
@@ skipping 185 matching lines @@
     scoped_ptr<base::DictionaryValue> response) {
   daemon_controller_->Stop(
       base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
                  base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetDaemonState(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
-  // TODO(lambroslambrou): Send the state as a string instead of an integer,
-  // and update the web-app accordingly.
   DaemonController::State state = daemon_controller_->GetState();
-  response->SetInteger("state", state);
+  switch (state) {
+    case DaemonController::STATE_NOT_IMPLEMENTED:
+      response->SetString("state", kStateNotImplemented);
+      break;
+    case DaemonController::STATE_NOT_INSTALLED:
+      response->SetString("state", kStateNotInstalled);
+      break;
+    case DaemonController::STATE_INSTALLING:
+      response->SetString("state", kStateInstalling);
+      break;
+    case DaemonController::STATE_STOPPED:
+      response->SetString("state", kStateStopped);
+      break;
+    case DaemonController::STATE_STARTING:
+      response->SetString("state", kStateStarting);
+      break;
+    case DaemonController::STATE_STARTED:
+      response->SetString("state", kStateStarted);
+      break;
+    case DaemonController::STATE_STOPPING:
+      response->SetString("state", kStateStopping);
+      break;
+    case DaemonController::STATE_UNKNOWN:
+      response->SetString("state", kStateUnknown);
+      break;
+  }
   SendResponse(response.Pass());
   return true;
 }
 
 void NativeMessagingHost::SendResponse(
     scoped_ptr<base::DictionaryValue> response) {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&NativeMessagingHost::SendResponse, weak_ptr_,
                               base::Passed(&response)));
@@ skipping 18 matching lines @@
     bool set_by_policy) {
   response->SetBoolean("supported", supported);
   response->SetBoolean("allowed", allowed);
   response->SetBoolean("set_by_policy", set_by_policy);
   SendResponse(response.Pass());
 }
 
 void NativeMessagingHost::SendAsyncResult(
     scoped_ptr<base::DictionaryValue> response,
     DaemonController::AsyncResult result) {
-  // TODO(lambroslambrou): Send the result as a string instead of an integer,
-  // and update the web-app accordingly. See http://crbug.com/232135.
-  response->SetInteger("result", result);
+  switch (result) {
+    case DaemonController::RESULT_OK:
+      response->SetString("result", kResultOk);
+      break;
+    case DaemonController::RESULT_FAILED:
+      response->SetString("result", kResultFailed);
+      break;
+    case DaemonController::RESULT_CANCELLED:
+      response->SetString("result", kResultCancelled);
+      break;
+    case DaemonController::RESULT_FAILED_DIRECTORY:
+      response->SetString("result", kResultFailedDirectory);
+      break;
+  }
   SendResponse(response.Pass());
 }
 
 }  // namespace remoting