Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

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 49 matching lines @@
                          const std::string& output_type,
                          const std::string& output) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&NotifyProcessOutput, browser_context, extension_id, tab_id,
                    terminal_id, output_type, output));
     return;
   }
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(new base::FundamentalValue(tab_id));
   args->Append(new base::FundamentalValue(terminal_id));
   args->Append(new base::StringValue(output_type));
   args->Append(new base::StringValue(output));
 
   extensions::EventRouter* event_router =
       extensions::EventRouter::Get(browser_context);
   if (event_router) {
-    scoped_ptr<extensions::Event> event(new extensions::Event(
+    std::unique_ptr<extensions::Event> event(new extensions::Event(
         extensions::events::TERMINAL_PRIVATE_ON_PROCESS_OUTPUT,
         terminal_private::OnProcessOutput::kEventName, std::move(args)));
     event_router->DispatchEventToExtension(extension_id, std::move(event));
   }
 }
 
 // Returns tab ID, or window session ID (for platform apps) for |web_contents|.
 int GetTabOrWindowSessionId(content::BrowserContext* browser_context,
                             content::WebContents* web_contents) {
   int tab_id = extensions::ExtensionTabUtil::GetTabId(web_contents);
@@ skipping 10 matching lines @@
 namespace extensions {
 
 TerminalPrivateOpenTerminalProcessFunction::
     TerminalPrivateOpenTerminalProcessFunction() : command_(NULL) {}
 
 TerminalPrivateOpenTerminalProcessFunction::
     ~TerminalPrivateOpenTerminalProcessFunction() {}
 
 ExtensionFunction::ResponseAction
 TerminalPrivateOpenTerminalProcessFunction::Run() {
-  scoped_ptr<OpenTerminalProcess::Params> params(
+  std::unique_ptr<OpenTerminalProcess::Params> params(
       OpenTerminalProcess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   command_ = GetProcessCommandForName(params->process_name);
   if (!command_)
     return RespondNow(Error("Invalid process name."));
 
   content::WebContents* caller_contents = GetSenderWebContents();
   if (!caller_contents)
     return RespondNow(Error("No web contents."));
@@ skipping 46 matching lines @@
   if (terminal_id < 0) {
     SetError("Failed to open process.");
     SendResponse(false);
     return;
   }
   SetResult(new base::FundamentalValue(terminal_id));
   SendResponse(true);
 }
 
 ExtensionFunction::ResponseAction TerminalPrivateSendInputFunction::Run() {
-  scoped_ptr<SendInput::Params> params(SendInput::Params::Create(*args_));
+  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(
@@ skipping 11 matching lines @@
 void TerminalPrivateSendInputFunction::RespondOnUIThread(bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
 }
 
 TerminalPrivateCloseTerminalProcessFunction::
     ~TerminalPrivateCloseTerminalProcessFunction() {}
 
 ExtensionFunction::ResponseAction
 TerminalPrivateCloseTerminalProcessFunction::Run() {
-  scoped_ptr<CloseTerminalProcess::Params> params(
+  std::unique_ptr<CloseTerminalProcess::Params> params(
       CloseTerminalProcess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Registry lives on the FILE thread.
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(
           &TerminalPrivateCloseTerminalProcessFunction::CloseOnFileThread, this,
           params->pid));
 
@@ skipping 14 matching lines @@
     bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
 }
 
 TerminalPrivateOnTerminalResizeFunction::
     ~TerminalPrivateOnTerminalResizeFunction() {}
 
 ExtensionFunction::ResponseAction
 TerminalPrivateOnTerminalResizeFunction::Run() {
-  scoped_ptr<OnTerminalResize::Params> params(
+  std::unique_ptr<OnTerminalResize::Params> params(
       OnTerminalResize::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Registry lives on the FILE thread.
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&TerminalPrivateOnTerminalResizeFunction::OnResizeOnFileThread,
                  this, params->pid, params->width, params->height));
 
   return RespondLater();
 }
@@ skipping 11 matching lines @@
 }
 
 void TerminalPrivateOnTerminalResizeFunction::RespondOnUIThread(bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
 }
 
 TerminalPrivateAckOutputFunction::~TerminalPrivateAckOutputFunction() {}
 
 ExtensionFunction::ResponseAction TerminalPrivateAckOutputFunction::Run() {
-  scoped_ptr<AckOutput::Params> params(AckOutput::Params::Create(*args_));
+  std::unique_ptr<AckOutput::Params> params(AckOutput::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   content::WebContents* caller_contents = GetSenderWebContents();
   if (!caller_contents)
     return RespondNow(Error("No web contents."));
 
   int tab_id = GetTabOrWindowSessionId(browser_context(), caller_contents);
   if (tab_id < 0)
     return RespondNow(Error("Not called from a tab or app window"));
 
   if (tab_id != params->tab_id)
     return RespondNow(NoArguments());
 
   // Registry lives on the FILE thread.
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&TerminalPrivateAckOutputFunction::AckOutputOnFileThread, this,
                  params->pid));
 
   return RespondNow(NoArguments());
 }
 
 void TerminalPrivateAckOutputFunction::AckOutputOnFileThread(int terminal_id) {
   chromeos::ProcessProxyRegistry::Get()->AckOutput(terminal_id);
 }
 
 }  // namespace extensions