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

chrome/browser/extensions/api/history/history_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/history/history_api.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/activity_log/activity_log.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 109 matching lines @@
 }
 
 HistoryEventRouter::~HistoryEventRouter() {
 }
 
 void HistoryEventRouter::OnURLVisited(history::HistoryService* history_service,
                                       ui::PageTransition transition,
                                       const history::URLRow& row,
                                       const history::RedirectList& redirects,
                                       base::Time visit_time) {
-  scoped_ptr<base::ListValue> args = OnVisited::Create(GetHistoryItem(row));
+  std::unique_ptr<base::ListValue> args =
+      OnVisited::Create(GetHistoryItem(row));
   DispatchEvent(profile_, events::HISTORY_ON_VISITED,
                 api::history::OnVisited::kEventName, std::move(args));
 }
 
 void HistoryEventRouter::OnURLsDeleted(history::HistoryService* history_service,
                                        bool all_history,
                                        bool expired,
                                        const history::URLRows& deleted_rows,
                                        const std::set<GURL>& favicon_urls) {
   OnVisitRemoved::Removed removed;
   removed.all_history = all_history;
 
   std::vector<std::string>* urls = new std::vector<std::string>();
   for (const auto& row : deleted_rows)
     urls->push_back(row.url().spec());
   removed.urls.reset(urls);
 
-  scoped_ptr<base::ListValue> args = OnVisitRemoved::Create(removed);
+  std::unique_ptr<base::ListValue> args = OnVisitRemoved::Create(removed);
   DispatchEvent(profile_, events::HISTORY_ON_VISIT_REMOVED,
                 api::history::OnVisitRemoved::kEventName, std::move(args));
 }
 
-void HistoryEventRouter::DispatchEvent(Profile* profile,
-                                       events::HistogramValue histogram_value,
-                                       const std::string& event_name,
-                                       scoped_ptr<base::ListValue> event_args) {
+void HistoryEventRouter::DispatchEvent(
+    Profile* profile,
+    events::HistogramValue histogram_value,
+    const std::string& event_name,
+    std::unique_ptr<base::ListValue> event_args) {
   if (profile && EventRouter::Get(profile)) {
-    scoped_ptr<Event> event(
+    std::unique_ptr<Event> event(
         new Event(histogram_value, event_name, std::move(event_args)));
     event->restrict_to_browser_context = profile;
     EventRouter::Get(profile)->BroadcastEvent(std::move(event));
   }
 }
 
 HistoryAPI::HistoryAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   event_router->RegisterObserver(this, api::history::OnVisited::kEventName);
@@ skipping 80 matching lines @@
       FROM_HERE,
       base::Bind(&HistoryFunctionWithCallback::SendResponseToCallback, this));
 }
 
 void HistoryFunctionWithCallback::SendResponseToCallback() {
   SendResponse(true);
   Release();  // Balanced in RunAsync().
 }
 
 bool HistoryGetVisitsFunction::RunAsyncImpl() {
-  scoped_ptr<GetVisits::Params> params(GetVisits::Params::Create(*args_));
+  std::unique_ptr<GetVisits::Params> params(GetVisits::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url;
   if (!ValidateUrl(params->details.url, &url))
     return false;
 
   history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
       GetProfile(), ServiceAccessType::EXPLICIT_ACCESS);
   hs->QueryURL(url,
                true,  // Retrieve full history of a URL.
@@ skipping 11 matching lines @@
   if (success && !visits.empty()) {
     for (const history::VisitRow& visit : visits)
       visit_item_vec.push_back(GetVisitItem(visit));
   }
 
   results_ = GetVisits::Results::Create(visit_item_vec);
   SendAsyncResponse();
 }
 
 bool HistorySearchFunction::RunAsyncImpl() {
-  scoped_ptr<Search::Params> params(Search::Params::Create(*args_));
+  std::unique_ptr<Search::Params> params(Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   base::string16 search_text = base::UTF8ToUTF16(params->query.text);
 
   history::QueryOptions options;
   options.SetRecentDayRange(1);
   options.max_count = 100;
 
   if (params->query.start_time.get())
     options.begin_time = GetTime(*params->query.start_time);
@@ skipping 17 matching lines @@
   HistoryItemList history_item_vec;
   if (results && !results->empty()) {
     for (const history::URLResult* item : *results)
       history_item_vec.push_back(GetHistoryItem(*item));
   }
   results_ = Search::Results::Create(history_item_vec);
   SendAsyncResponse();
 }
 
 bool HistoryAddUrlFunction::RunAsync() {
-  scoped_ptr<AddUrl::Params> params(AddUrl::Params::Create(*args_));
+  std::unique_ptr<AddUrl::Params> params(AddUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url;
   if (!ValidateUrl(params->details.url, &url))
     return false;
 
   history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
       GetProfile(), ServiceAccessType::EXPLICIT_ACCESS);
   hs->AddPage(url, base::Time::Now(), history::SOURCE_EXTENSION);
 
   SendResponse(true);
   return true;
 }
 
 bool HistoryDeleteUrlFunction::RunAsync() {
-  scoped_ptr<DeleteUrl::Params> params(DeleteUrl::Params::Create(*args_));
+  std::unique_ptr<DeleteUrl::Params> params(DeleteUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!VerifyDeleteAllowed())
     return false;
 
   GURL url;
   if (!ValidateUrl(params->details.url, &url))
     return false;
 
   history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
       GetProfile(), ServiceAccessType::EXPLICIT_ACCESS);
   hs->DeleteURL(url);
 
   // Also clean out from the activity log. If the activity log testing flag is
   // set then don't clean so testers can see what potentially malicious
   // extensions have been trying to clean from their logs.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExtensionActivityLogTesting)) {
     ActivityLog* activity_log = ActivityLog::GetInstance(GetProfile());
     DCHECK(activity_log);
     activity_log->RemoveURL(url);
   }
 
   SendResponse(true);
   return true;
 }
 
 bool HistoryDeleteRangeFunction::RunAsyncImpl() {
-  scoped_ptr<DeleteRange::Params> params(DeleteRange::Params::Create(*args_));
+  std::unique_ptr<DeleteRange::Params> params(
+      DeleteRange::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!VerifyDeleteAllowed())
     return false;
 
   base::Time start_time = GetTime(params->range.start_time);
   base::Time end_time = GetTime(params->range.end_time);
 
   std::set<GURL> restrict_urls;
   history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
@@ skipping 45 matching lines @@
   }
 
   return true;
 }
 
 void HistoryDeleteAllFunction::DeleteComplete() {
   SendAsyncResponse();
 }
 
 }  // namespace extensions