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

chrome/browser/extensions/api/log_private/log_private_api_chromeos.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 "chrome/browser/extensions/api/log_private/log_private_api.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/api/log_private/filter_handler.h"
 #include "chrome/browser/extensions/api/log_private/log_parser.h"
 #include "chrome/browser/extensions/api/log_private/syslog_parser.h"
 #include "chrome/browser/feedback/system_logs/scrubbed_system_logs_fetcher.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 34 matching lines @@
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
 // Checks if we are running on sequenced task runner thread.
 bool IsRunningOnSequenceThread() {
   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
   return pool->IsRunningSequenceOnCurrentThread(
       pool->GetNamedSequenceToken(FileResource::kSequenceToken));
 }
 
-scoped_ptr<LogParser> CreateLogParser(const std::string& log_type) {
+std::unique_ptr<LogParser> CreateLogParser(const std::string& log_type) {
   if (log_type == "syslog")
-    return scoped_ptr<LogParser>(new SyslogParser());
+    return std::unique_ptr<LogParser>(new SyslogParser());
   // TODO(shinfan): Add more parser here
 
   NOTREACHED() << "Invalid log type: " << log_type;
-  return  scoped_ptr<LogParser>();
+  return std::unique_ptr<LogParser>();
 }
 
 void CollectLogInfo(FilterHandler* filter_handler,
                     system_logs::SystemLogsResponse* logs,
                     std::vector<api::log_private::LogEntry>* output) {
   for (system_logs::SystemLogsResponse::const_iterator
       request_it = logs->begin(); request_it != logs->end(); ++request_it) {
     if (!filter_handler->IsValidSource(request_it->first)) {
       continue;
     }
-    scoped_ptr<LogParser> parser(CreateLogParser(request_it->first));
+    std::unique_ptr<LogParser> parser(CreateLogParser(request_it->first));
     if (parser) {
       parser->Parse(request_it->second, output, filter_handler);
     }
   }
 }
 
 // Returns directory location of app-specific logs that are initiated with
 // logPrivate.startEventRecorder() calls - /home/chronos/user/log/apps
 base::FilePath GetAppLogDirectory() {
   return logging::GetSessionLogDir(*base::CommandLine::ForCurrentProcess())
@@ skipping 135 matching lines @@
 }
 
 void LogPrivateAPI::PostPendingEntries() {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&LogPrivateAPI:: AddEntriesOnUI,
                  base::Unretained(this),
                  base::Passed(&pending_entries_)));
 }
 
-void LogPrivateAPI::AddEntriesOnUI(scoped_ptr<base::ListValue> value) {
+void LogPrivateAPI::AddEntriesOnUI(std::unique_ptr<base::ListValue> value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (std::set<std::string>::iterator ix = net_internal_watches_.begin();
        ix != net_internal_watches_.end(); ++ix) {
     // Create the event's arguments value.
-    scoped_ptr<base::ListValue> event_args(new base::ListValue());
+    std::unique_ptr<base::ListValue> event_args(new base::ListValue());
     event_args->Append(value->DeepCopy());
-    scoped_ptr<Event> event(
+    std::unique_ptr<Event> event(
         new Event(::extensions::events::LOG_PRIVATE_ON_CAPTURED_EVENTS,
                   ::events::kOnCapturedEvents, std::move(event_args)));
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(*ix, std::move(event));
   }
 }
 
 void LogPrivateAPI::CreateTempNetLogFile(const std::string& owner_extension_id,
                                          base::ScopedFILE* file) {
   DCHECK(IsRunningOnSequenceThread());
@@ skipping 133 matching lines @@
 }
 
 LogPrivateGetHistoricalFunction::LogPrivateGetHistoricalFunction() {
 }
 
 LogPrivateGetHistoricalFunction::~LogPrivateGetHistoricalFunction() {
 }
 
 bool LogPrivateGetHistoricalFunction::RunAsync() {
   // Get parameters
-  scoped_ptr<api::log_private::GetHistorical::Params> params(
+  std::unique_ptr<api::log_private::GetHistorical::Params> params(
       api::log_private::GetHistorical::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   filter_handler_.reset(new FilterHandler(params->filter));
 
   system_logs::SystemLogsFetcherBase* fetcher;
   if ((params->filter).scrub) {
     fetcher = new system_logs::ScrubbedSystemLogsFetcher();
   } else {
     fetcher = new system_logs::AboutSystemLogsFetcher();
   }
   fetcher->Fetch(
       base::Bind(&LogPrivateGetHistoricalFunction::OnSystemLogsLoaded, this));
 
   return true;
 }
 
 void LogPrivateGetHistoricalFunction::OnSystemLogsLoaded(
-    scoped_ptr<system_logs::SystemLogsResponse> sys_info) {
-
+    std::unique_ptr<system_logs::SystemLogsResponse> sys_info) {
   // Prepare result
   api::log_private::Result result;
   CollectLogInfo(filter_handler_.get(), sys_info.get(), &result.data);
   api::log_private::Filter::Populate(
       *((filter_handler_->GetFilter())->ToValue()), &result.filter);
   SetResult(result.ToValue().release());
   SendResponse(true);
 }
 
 LogPrivateStartEventRecorderFunction::LogPrivateStartEventRecorderFunction() {
 }
 
 LogPrivateStartEventRecorderFunction::~LogPrivateStartEventRecorderFunction() {
 }
 
 bool LogPrivateStartEventRecorderFunction::RunAsync() {
-  scoped_ptr<api::log_private::StartEventRecorder::Params> params(
+  std::unique_ptr<api::log_private::StartEventRecorder::Params> params(
       api::log_private::StartEventRecorder::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   switch (params->event_type) {
     case api::log_private::EVENT_TYPE_NETWORK:
       LogPrivateAPI::Get(Profile::FromBrowserContext(browser_context()))
           ->StartNetInternalsWatch(
               extension_id(),
               params->sink,
               base::Bind(
                   &LogPrivateStartEventRecorderFunction::OnEventRecorderStarted,
@@ skipping 11 matching lines @@
   SendResponse(true);
 }
 
 LogPrivateStopEventRecorderFunction::LogPrivateStopEventRecorderFunction() {
 }
 
 LogPrivateStopEventRecorderFunction::~LogPrivateStopEventRecorderFunction() {
 }
 
 bool LogPrivateStopEventRecorderFunction::RunAsync() {
-  scoped_ptr<api::log_private::StopEventRecorder::Params> params(
+  std::unique_ptr<api::log_private::StopEventRecorder::Params> params(
       api::log_private::StopEventRecorder::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   switch (params->event_type) {
     case api::log_private::EVENT_TYPE_NETWORK:
       LogPrivateAPI::Get(Profile::FromBrowserContext(browser_context()))
           ->StopNetInternalsWatch(
               extension_id(),
               base::Bind(
                   &LogPrivateStopEventRecorderFunction::OnEventRecorderStopped,
                   this));
@@ skipping 31 matching lines @@
 }
 
 void LogPrivateDumpLogsFunction::OnStoreLogsCompleted(
     const base::FilePath& log_path,
     bool succeeded) {
   if (succeeded) {
     LogPrivateAPI::Get(Profile::FromBrowserContext(browser_context()))
         ->RegisterTempFile(extension_id(), log_path);
   }
 
-  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue());
   extensions::GrantedFileEntry file_entry =
       extensions::app_file_handler_util::CreateFileEntry(
           Profile::FromBrowserContext(browser_context()),
           extension(),
           render_frame_host()->GetProcess()->GetID(),
           log_path,
           false);
 
   base::DictionaryValue* entry = new base::DictionaryValue();
   entry->SetString("fileSystemId", file_entry.filesystem_id);
   entry->SetString("baseName", file_entry.registered_name);
   entry->SetString("id", file_entry.id);
   entry->SetBoolean("isDirectory", false);
   base::ListValue* entry_list = new base::ListValue();
   entry_list->Append(entry);
   response->Set("entries", entry_list);
   response->SetBoolean("multiple", false);
   SetResult(response.release());
   SendResponse(succeeded);
 }
 
 }  // namespace extensions