Disable Me2Me host controls on unsupported Linux systems.

remoting/host/setup/daemon_controller_delegate_linux.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_delegate_linux.h"
 
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 96 matching lines @@
   if (!base::WaitForExitCodeWithTimeout(process_handle, exit_code, timeout)) {
     base::KillProcess(process_handle, 0, false);
     LOG(ERROR) << "Timeout exceeded for command: "
                << command_line.GetCommandLineString();
     return false;
   }
 
   return true;
 }
 
-bool RunHostScript(const std::vector<std::string>& args,
-                          int* exit_code) {
+bool RunHostScript(const std::vector<std::string>& args, int* exit_code) {
   return RunHostScriptWithTimeout(
       args, base::TimeDelta::FromMilliseconds(kDaemonTimeoutMs), exit_code);
 }
 
 }  // namespace
 
 DaemonControllerDelegateLinux::DaemonControllerDelegateLinux() {
 }
 
 DaemonControllerDelegateLinux::~DaemonControllerDelegateLinux() {
 }
 
 DaemonController::State DaemonControllerDelegateLinux::GetState() {
-  std::vector<std::string> args;
-  args.push_back("--check-running");
+  base::FilePath script_path;
+  if (!GetScriptPath(&script_path)) {
+    return DaemonController::STATE_NOT_IMPLEMENTED;
+  }
+  CommandLine command_line(script_path);
+  command_line.AppendArg("--get-status");
+
+  std::string status;
   int exit_code = 0;
-  if (!RunHostScript(args, &exit_code)) {
+  bool result =
+      base::GetAppOutputWithExitCode(command_line, &status, &exit_code);
+  if (!result) {
     // TODO(jamiewalch): When we have a good story for installing, return
     // NOT_INSTALLED rather than NOT_IMPLEMENTED (the former suppresses
     // the relevant UI in the web-app).
     return DaemonController::STATE_NOT_IMPLEMENTED;
   }
 
-  if (exit_code == 0) {
+  if (exit_code != 0) {
+    LOG(ERROR) << "Failed to run \"" << command_line.GetCommandLineString()
+               << "\". Exit code: " << exit_code;
+    return DaemonController::STATE_UNKNOWN;
+  }
+
+  TrimWhitespaceASCII(status, TRIM_ALL, &status);
+
+  if (status == "STARTED") {
     return DaemonController::STATE_STARTED;
+  } else if (status == "STOPPED") {
+    return DaemonController::STATE_STOPPED;
+  } else if (status == "NOT_IMPLEMENTED") {
+    return DaemonController::STATE_NOT_IMPLEMENTED;
   } else {
-    return DaemonController::STATE_STOPPED;
+    LOG(ERROR) << "Unknown status string returned from  \""
+               << command_line.GetCommandLineString()
+               << "\": " << status;
+    return DaemonController::STATE_UNKNOWN;
   }
 }
 
 scoped_ptr<base::DictionaryValue> DaemonControllerDelegateLinux::GetConfig() {
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 
   if (GetState() != DaemonController::STATE_NOT_IMPLEMENTED) {
     JsonHostConfig config(GetConfigPath());
     if (config.Read()) {
       std::string value;
@@ skipping 132 matching lines @@
   return consent;
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   scoped_ptr<DaemonController::Delegate> delegate(
       new DaemonControllerDelegateLinux());
   return new DaemonController(delegate.Pass());
 }
 
 }  // namespace remoting