chrome: Add support for custom crosh command.

chrome/browser/extensions/api/terminal/terminal_private_api.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/terminal/terminal_private_api.h"
 
 #include <utility>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/terminal/terminal_extension_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/terminal_private.h"
 #include "chromeos/process_proxy/process_proxy_registry.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/event_router.h"
 
 namespace terminal_private = extensions::api::terminal_private;
 namespace OnTerminalResize =
     extensions::api::terminal_private::OnTerminalResize;
 namespace OpenTerminalProcess =
     extensions::api::terminal_private::OpenTerminalProcess;
 namespace CloseTerminalProcess =
     extensions::api::terminal_private::CloseTerminalProcess;
 namespace SendInput = extensions::api::terminal_private::SendInput;
 namespace AckOutput = extensions::api::terminal_private::AckOutput;
 
 namespace {
 
 const char kCroshName[] = "crosh";
 const char kCroshCommand[] = "/usr/bin/crosh";
 // We make stubbed crosh just echo back input.
 const char kStubbedCroshCommand[] = "cat";
 
-const char* GetCroshPath() {
+std::string GetCroshPath() {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kCroshCommand))
+    return command_line->GetSwitchValueASCII(switches::kCroshCommand);
   if (base::SysInfo::IsRunningOnChromeOS())
-    return kCroshCommand;
+    return std::string(kCroshCommand);
   else

[benwells, 2017/01/10 22:25:07]

Nit: While here can you remove this else (no else after return).

[reveman, 2017/01/11 00:33:01]

Done.

-    return kStubbedCroshCommand;
+    return std::string(kStubbedCroshCommand);
 }
 
-const char* GetProcessCommandForName(const std::string& name) {
+std::string GetProcessCommandForName(const std::string& name) {
   if (name == kCroshName)
     return GetCroshPath();
   else
-    return NULL;
+    return std::string();
 }
 
 void NotifyProcessOutput(content::BrowserContext* browser_context,
                          const std::string& extension_id,
                          int tab_id,
                          int terminal_id,
                          const std::string& output_type,
                          const std::string& output) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
@@ skipping 29 matching lines @@
       extensions::AppWindowRegistry::Get(browser_context)
           ->GetAppWindowForWebContents(web_contents);
   return window ? window->session_id().id() : -1;
 }
 
 }  // namespace
 
 namespace extensions {
 
 TerminalPrivateOpenTerminalProcessFunction::
-    TerminalPrivateOpenTerminalProcessFunction() : command_(NULL) {}
+    TerminalPrivateOpenTerminalProcessFunction() {}
 
 TerminalPrivateOpenTerminalProcessFunction::
     ~TerminalPrivateOpenTerminalProcessFunction() {}
 
 ExtensionFunction::ResponseAction
 TerminalPrivateOpenTerminalProcessFunction::Run() {
   std::unique_ptr<OpenTerminalProcess::Params> params(
       OpenTerminalProcess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   command_ = GetProcessCommandForName(params->process_name);
-  if (!command_)
+  if (command_.empty())
     return RespondNow(Error("Invalid process name."));
 
   content::WebContents* caller_contents = GetSenderWebContents();
   if (!caller_contents)
     return RespondNow(Error("No web contents."));
 
   // Passed to terminalPrivate.ackOutput, which is called from the API's custom
   // bindings after terminalPrivate.onProcessOutput is dispatched. It is used to
   // determine whether ackOutput call should be handled or not. ackOutput will
   // be called from every web contents in which a onProcessOutput listener
@@ skipping 16 matching lines @@
                      tab_id),
           base::Bind(
               &TerminalPrivateOpenTerminalProcessFunction::RespondOnUIThread,
               this)));
   return RespondLater();
 }
 
 void TerminalPrivateOpenTerminalProcessFunction::OpenOnFileThread(
     const ProcessOutputCallback& output_callback,
     const OpenProcessCallback& callback) {
-  DCHECK(command_);
+  DCHECK(!command_.empty());
 
   chromeos::ProcessProxyRegistry* registry =
       chromeos::ProcessProxyRegistry::Get();
 
-  int terminal_id = registry->OpenProcess(command_, output_callback);
+  int terminal_id = registry->OpenProcess(command_.c_str(), output_callback);
 
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                    base::Bind(callback, terminal_id));
 }
 
 TerminalPrivateSendInputFunction::~TerminalPrivateSendInputFunction() {}
 
 void TerminalPrivateOpenTerminalProcessFunction::RespondOnUIThread(
     int terminal_id) {
   if (terminal_id < 0) {
@@ skipping 121 matching lines @@
                  params->pid));
 
   return RespondNow(NoArguments());
 }
 
 void TerminalPrivateAckOutputFunction::AckOutputOnFileThread(int terminal_id) {
   chromeos::ProcessProxyRegistry::Get()->AckOutput(terminal_id);
 }
 
 }  // namespace extensions