[Extensions] Consolidate ExtensionFunction::SendResponse()s

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/json/json_writer.h"
@@ skipping 148 matching lines @@
 
   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) {
-    SetError("Failed to open process.");
-    SendResponse(false);
+    Respond(Error("Failed to open process."));
     return;
   }
-  SetResult(base::MakeUnique<base::FundamentalValue>(terminal_id));
-  SendResponse(true);
+  Respond(OneArgument(base::MakeUnique<base::FundamentalValue>(terminal_id)));
 }
 
 ExtensionFunction::ResponseAction TerminalPrivateSendInputFunction::Run() {
   std::unique_ptr<SendInput::Params> params(SendInput::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Registry lives on the FILE thread.
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&TerminalPrivateSendInputFunction::SendInputOnFileThread,
                  this, params->pid, params->input));
   return RespondLater();
 }
 
 void TerminalPrivateSendInputFunction::SendInputOnFileThread(
     int terminal_id,
     const std::string& text) {
   bool success =
       chromeos::ProcessProxyRegistry::Get()->SendInput(terminal_id, text);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&TerminalPrivateSendInputFunction::RespondOnUIThread, this,
                  success));
 }
 
 void TerminalPrivateSendInputFunction::RespondOnUIThread(bool success) {
-  SetResult(base::MakeUnique<base::FundamentalValue>(success));
-  SendResponse(true);
+  Respond(OneArgument(base::MakeUnique<base::FundamentalValue>(success)));
 }
 
 TerminalPrivateCloseTerminalProcessFunction::
     ~TerminalPrivateCloseTerminalProcessFunction() {}
 
 ExtensionFunction::ResponseAction
 TerminalPrivateCloseTerminalProcessFunction::Run() {
   std::unique_ptr<CloseTerminalProcess::Params> params(
       CloseTerminalProcess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ skipping 13 matching lines @@
   bool success =
       chromeos::ProcessProxyRegistry::Get()->CloseProcess(terminal_id);
 
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&TerminalPrivateCloseTerminalProcessFunction::
                  RespondOnUIThread, this, success));
 }
 
 void TerminalPrivateCloseTerminalProcessFunction::RespondOnUIThread(
     bool success) {
-  SetResult(base::MakeUnique<base::FundamentalValue>(success));
-  SendResponse(true);
+  Respond(OneArgument(base::MakeUnique<base::FundamentalValue>(success)));
 }
 
 TerminalPrivateOnTerminalResizeFunction::
     ~TerminalPrivateOnTerminalResizeFunction() {}
 
 ExtensionFunction::ResponseAction
 TerminalPrivateOnTerminalResizeFunction::Run() {
   std::unique_ptr<OnTerminalResize::Params> params(
       OnTerminalResize::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ skipping 12 matching lines @@
     int height) {
   bool success = chromeos::ProcessProxyRegistry::Get()->OnTerminalResize(
       terminal_id, width, height);
 
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&TerminalPrivateOnTerminalResizeFunction::RespondOnUIThread,
                  this, success));
 }
 
 void TerminalPrivateOnTerminalResizeFunction::RespondOnUIThread(bool success) {
-  SetResult(base::MakeUnique<base::FundamentalValue>(success));
-  SendResponse(true);
+  Respond(OneArgument(base::MakeUnique<base::FundamentalValue>(success)));
 }
 
 TerminalPrivateAckOutputFunction::~TerminalPrivateAckOutputFunction() {}
 
 ExtensionFunction::ResponseAction TerminalPrivateAckOutputFunction::Run() {
   std::unique_ptr<AckOutput::Params> params(AckOutput::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   content::WebContents* caller_contents = GetSenderWebContents();
   if (!caller_contents)
@@ skipping 13 matching lines @@
                  params->pid));
 
   return RespondNow(NoArguments());
 }
 
 void TerminalPrivateAckOutputFunction::AckOutputOnFileThread(int terminal_id) {
   chromeos::ProcessProxyRegistry::Get()->AckOutput(terminal_id);
 }
 
 }  // namespace extensions