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

chrome/browser/extensions/api/downloads/downloads_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/downloads/downloads_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <set>
 #include <string>
@@ skipping 227 matching lines @@
 
 std::string TimeToISO8601(const base::Time& t) {
   base::Time::Exploded exploded;
   t.UTCExplode(&exploded);
   return base::StringPrintf(
       "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", exploded.year, exploded.month,
       exploded.day_of_month, exploded.hour, exploded.minute, exploded.second,
       exploded.millisecond);
 }
 
-scoped_ptr<base::DictionaryValue> DownloadItemToJSON(
+std::unique_ptr<base::DictionaryValue> DownloadItemToJSON(
     DownloadItem* download_item,
     Profile* profile) {
   base::DictionaryValue* json = new base::DictionaryValue();
   json->SetBoolean(kExistsKey, !download_item->GetFileExternallyRemoved());
   json->SetInteger(kIdKey, download_item->GetId());
   const GURL& url = download_item->GetOriginalUrl();
   json->SetString(kUrlKey, (url.is_valid() ? url.spec() : std::string()));
   const GURL& referrer = download_item->GetReferrerUrl();
   json->SetString(kReferrerUrlKey, (referrer.is_valid() ? referrer.spec()
                                                         : std::string()));
@@ skipping 32 matching lines @@
     // language. This won't work if the extension was uninstalled, so the name
     // might be the wrong language.
     const Extension* extension =
         ExtensionRegistry::Get(profile)
             ->GetExtensionById(by_ext->id(), ExtensionRegistry::EVERYTHING);
     if (extension)
       json->SetString(kByExtensionNameKey, extension->name());
   }
   // TODO(benjhayden): Implement fileSize.
   json->SetDouble(kFileSizeKey, download_item->GetTotalBytes());
-  return scoped_ptr<base::DictionaryValue>(json);
+  return std::unique_ptr<base::DictionaryValue>(json);
 }
 
 class DownloadFileIconExtractorImpl : public DownloadFileIconExtractor {
  public:
   DownloadFileIconExtractorImpl() {}
 
   ~DownloadFileIconExtractorImpl() override {}
 
   bool ExtractIconURLForPath(const base::FilePath& path,
                              float scale,
@@ skipping 221 matching lines @@
       return;
     }
     query_out.AddFilter(danger_type);
   }
   if (query_in.order_by.get()) {
     CompileDownloadQueryOrderBy(*query_in.order_by.get(), error, &query_out);
     if (!error->empty())
       return;
   }
 
-  scoped_ptr<base::DictionaryValue> query_in_value(query_in.ToValue());
+  std::unique_ptr<base::DictionaryValue> query_in_value(query_in.ToValue());
   for (base::DictionaryValue::Iterator query_json_field(*query_in_value.get());
        !query_json_field.IsAtEnd(); query_json_field.Advance()) {
     FilterTypeMap::const_iterator filter_type =
         filter_types.Get().find(query_json_field.key());
     if (filter_type != filter_types.Get().end()) {
       if (!query_out.AddFilter(filter_type->second, query_json_field.value())) {
         *error = errors::kInvalidFilter;
         return;
       }
     }
@@ skipping 37 matching lines @@
     return (data == NULL) ? NULL :
         static_cast<ExtensionDownloadsEventRouterData*>(data);
   }
 
   static void Remove(DownloadItem* download_item) {
     download_item->RemoveUserData(kKey);
   }
 
   explicit ExtensionDownloadsEventRouterData(
       DownloadItem* download_item,
-      scoped_ptr<base::DictionaryValue> json_item)
+      std::unique_ptr<base::DictionaryValue> json_item)
       : updated_(0),
         changed_fired_(0),
         json_(std::move(json_item)),
         creator_conflict_action_(downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY),
         determined_conflict_action_(
             downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     download_item->SetUserData(kKey, this);
   }
 
   ~ExtensionDownloadsEventRouterData() override {
     if (updated_ > 0) {
       UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged",
                                (changed_fired_ * 100 / updated_));
     }
   }
 
   const base::DictionaryValue& json() const { return *json_.get(); }
-  void set_json(scoped_ptr<base::DictionaryValue> json_item) {
+  void set_json(std::unique_ptr<base::DictionaryValue> json_item) {
     json_ = std::move(json_item);
   }
 
   void OnItemUpdated() { ++updated_; }
   void OnChangedFired() { ++changed_fired_; }
 
   static void SetDetermineFilenameTimeoutSecondsForTesting(int s) {
     determine_filename_timeout_s_ = s;
   }
 
@@ skipping 198 matching lines @@
       }
     }
     // Clear the callbacks immediately in case they aren't idempotent.
     filename_no_change_ = base::Closure();
     filename_change_ = ExtensionDownloadsEventRouter::FilenameChangedCallback();
   }
 
 
   int updated_;
   int changed_fired_;
-  scoped_ptr<base::DictionaryValue> json_;
+  std::unique_ptr<base::DictionaryValue> json_;
 
   base::Closure filename_no_change_;
   ExtensionDownloadsEventRouter::FilenameChangedCallback filename_change_;
 
   DeterminerInfoVector determiners_;
 
   base::FilePath creator_suggested_filename_;
   downloads::FilenameConflictAction
     creator_conflict_action_;
   base::FilePath determined_filename_;
   downloads::FilenameConflictAction
     determined_conflict_action_;
   DeterminerInfo determiner_;
 
-  scoped_ptr<base::WeakPtrFactory<ExtensionDownloadsEventRouterData> >
-    weak_ptr_factory_;
+  std::unique_ptr<base::WeakPtrFactory<ExtensionDownloadsEventRouterData>>
+      weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloadsEventRouterData);
 };
 
 int ExtensionDownloadsEventRouterData::determine_filename_timeout_s_ = 15;
 
 ExtensionDownloadsEventRouterData::DeterminerInfo::DeterminerInfo(
     const std::string& e_id,
     const base::Time& installed)
     : extension_id(e_id),
@@ skipping 72 matching lines @@
   : id_(id),
     name_(name) {
   item->SetUserData(kKey, this);
 }
 
 DownloadsDownloadFunction::DownloadsDownloadFunction() {}
 
 DownloadsDownloadFunction::~DownloadsDownloadFunction() {}
 
 bool DownloadsDownloadFunction::RunAsync() {
-  scoped_ptr<downloads::Download::Params> params(
+  std::unique_ptr<downloads::Download::Params> params(
       downloads::Download::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const downloads::DownloadOptions& options = params->options;
   GURL download_url(options.url);
   if (Fault(!download_url.is_valid(), errors::kInvalidURL, &error_))
     return false;
 
   Profile* current_profile = GetProfile();
   if (include_incognito() && GetProfile()->HasOffTheRecordProfile())
     current_profile = GetProfile()->GetOffTheRecordProfile();
 
-  scoped_ptr<content::DownloadUrlParameters> download_params(
+  std::unique_ptr<content::DownloadUrlParameters> download_params(
       new content::DownloadUrlParameters(
           download_url, render_frame_host()->GetProcess()->GetID(),
           render_view_host_do_not_use()->GetRoutingID(),
           render_frame_host()->GetRoutingID(),
           current_profile->GetResourceContext()));
 
   base::FilePath creator_suggested_filename;
   if (options.filename.get()) {
 #if defined(OS_WIN)
     // Can't get filename16 from options.ToValue() because that converts it from
@@ skipping 64 matching lines @@
   if (item) {
     DCHECK_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
     SetResult(new base::FundamentalValue(static_cast<int>(item->GetId())));
     if (!creator_suggested_filename.empty() ||
         (creator_conflict_action !=
          downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY)) {
       ExtensionDownloadsEventRouterData* data =
           ExtensionDownloadsEventRouterData::Get(item);
       if (!data) {
         data = new ExtensionDownloadsEventRouterData(
-            item,
-            scoped_ptr<base::DictionaryValue>(new base::DictionaryValue()));
+            item, std::unique_ptr<base::DictionaryValue>(
+                      new base::DictionaryValue()));
       }
       data->CreatorSuggestedFilename(
           creator_suggested_filename, creator_conflict_action);
     }
     new DownloadedByExtension(item, extension()->id(), extension()->name());
     item->UpdateObservers();
   } else {
     DCHECK_NE(content::DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
     error_ = content::DownloadInterruptReasonToString(interrupt_reason);
   }
   SendResponse(error_.empty());
 }
 
 DownloadsSearchFunction::DownloadsSearchFunction() {}
 
 DownloadsSearchFunction::~DownloadsSearchFunction() {}
 
 bool DownloadsSearchFunction::RunSync() {
-  scoped_ptr<downloads::Search::Params> params(
+  std::unique_ptr<downloads::Search::Params> params(
       downloads::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
   GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
   ExtensionDownloadsEventRouter* router =
       DownloadServiceFactory::GetForBrowserContext(
           manager->GetBrowserContext())->GetExtensionEventRouter();
   router->CheckForHistoryFilesRemoval();
   if (incognito_manager) {
@@ skipping 11 matching lines @@
   if (!error_.empty())
     return false;
 
   base::ListValue* json_results = new base::ListValue();
   for (DownloadManager::DownloadVector::const_iterator it = results.begin();
        it != results.end(); ++it) {
     DownloadItem* download_item = *it;
     uint32_t download_id = download_item->GetId();
     bool off_record = ((incognito_manager != NULL) &&
                        (incognito_manager->GetDownload(download_id) != NULL));
-    scoped_ptr<base::DictionaryValue> json_item(
-        DownloadItemToJSON(*it,
-                           off_record ? GetProfile()->GetOffTheRecordProfile()
-                                      : GetProfile()->GetOriginalProfile()));
+    std::unique_ptr<base::DictionaryValue> json_item(DownloadItemToJSON(
+        *it, off_record ? GetProfile()->GetOffTheRecordProfile()
+                        : GetProfile()->GetOriginalProfile()));
     json_results->Append(json_item.release());
   }
   SetResult(json_results);
   RecordApiFunctions(DOWNLOADS_FUNCTION_SEARCH);
   return true;
 }
 
 DownloadsPauseFunction::DownloadsPauseFunction() {}
 
 DownloadsPauseFunction::~DownloadsPauseFunction() {}
 
 bool DownloadsPauseFunction::RunSync() {
-  scoped_ptr<downloads::Pause::Params> params(
+  std::unique_ptr<downloads::Pause::Params> params(
       downloads::Pause::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->GetState() != DownloadItem::IN_PROGRESS,
             errors::kNotInProgress, &error_))
     return false;
   // If the item is already paused, this is a no-op and the operation will
   // silently succeed.
   download_item->Pause();
   RecordApiFunctions(DOWNLOADS_FUNCTION_PAUSE);
   return true;
 }
 
 DownloadsResumeFunction::DownloadsResumeFunction() {}
 
 DownloadsResumeFunction::~DownloadsResumeFunction() {}
 
 bool DownloadsResumeFunction::RunSync() {
-  scoped_ptr<downloads::Resume::Params> params(
+  std::unique_ptr<downloads::Resume::Params> params(
       downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->IsPaused() && !download_item->CanResume(),
             errors::kNotResumable, &error_))
     return false;
   // Note that if the item isn't paused, this will be a no-op, and the extension
   // call will seem successful.
   download_item->Resume();
   RecordApiFunctions(DOWNLOADS_FUNCTION_RESUME);
   return true;
 }
 
 DownloadsCancelFunction::DownloadsCancelFunction() {}
 
 DownloadsCancelFunction::~DownloadsCancelFunction() {}
 
 bool DownloadsCancelFunction::RunSync() {
-  scoped_ptr<downloads::Resume::Params> params(
+  std::unique_ptr<downloads::Resume::Params> params(
       downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (download_item &&
       (download_item->GetState() == DownloadItem::IN_PROGRESS))
     download_item->Cancel(true);
   // |download_item| can be NULL if the download ID was invalid or if the
   // download is not currently active.  Either way, it's not a failure.
   RecordApiFunctions(DOWNLOADS_FUNCTION_CANCEL);
   return true;
 }
 
 DownloadsEraseFunction::DownloadsEraseFunction() {}
 
 DownloadsEraseFunction::~DownloadsEraseFunction() {}
 
 bool DownloadsEraseFunction::RunSync() {
-  scoped_ptr<downloads::Erase::Params> params(
+  std::unique_ptr<downloads::Erase::Params> params(
       downloads::Erase::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
   GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
   DownloadQuery::DownloadVector results;
   RunDownloadQuery(params->query,
                    manager,
                    incognito_manager,
                    &error_,
@@ skipping 12 matching lines @@
   return true;
 }
 
 DownloadsRemoveFileFunction::DownloadsRemoveFileFunction() {
 }
 
 DownloadsRemoveFileFunction::~DownloadsRemoveFileFunction() {
 }
 
 bool DownloadsRemoveFileFunction::RunAsync() {
-  scoped_ptr<downloads::RemoveFile::Params> params(
+  std::unique_ptr<downloads::RemoveFile::Params> params(
       downloads::RemoveFile::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault((download_item->GetState() != DownloadItem::COMPLETE),
             errors::kNotComplete, &error_) ||
       Fault(download_item->GetFileExternallyRemoved(),
             errors::kFileAlreadyDeleted, &error_))
     return false;
@@ skipping 12 matching lines @@
 }
 
 DownloadsAcceptDangerFunction::DownloadsAcceptDangerFunction() {}
 
 DownloadsAcceptDangerFunction::~DownloadsAcceptDangerFunction() {}
 
 DownloadsAcceptDangerFunction::OnPromptCreatedCallback*
     DownloadsAcceptDangerFunction::on_prompt_created_ = NULL;
 
 bool DownloadsAcceptDangerFunction::RunAsync() {
-  scoped_ptr<downloads::AcceptDanger::Params> params(
+  std::unique_ptr<downloads::AcceptDanger::Params> params(
       downloads::AcceptDanger::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   PromptOrWait(params->download_id, 10);
   return true;
 }
 
 void DownloadsAcceptDangerFunction::PromptOrWait(int download_id, int retries) {
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), download_id);
   content::WebContents* web_contents = dispatcher()->GetVisibleWebContents();
@@ skipping 53 matching lines @@
       break;
   }
   SendResponse(error_.empty());
 }
 
 DownloadsShowFunction::DownloadsShowFunction() {}
 
 DownloadsShowFunction::~DownloadsShowFunction() {}
 
 bool DownloadsShowFunction::RunAsync() {
-  scoped_ptr<downloads::Show::Params> params(
+  std::unique_ptr<downloads::Show::Params> params(
       downloads::Show::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_))
     return false;
   download_item->ShowDownloadInShell();
   RecordApiFunctions(DOWNLOADS_FUNCTION_SHOW);
   return true;
 }
@@ skipping 11 matching lines @@
       platform_util::OPEN_FOLDER, platform_util::OpenOperationCallback());
   RecordApiFunctions(DOWNLOADS_FUNCTION_SHOW_DEFAULT_FOLDER);
   return true;
 }
 
 DownloadsOpenFunction::DownloadsOpenFunction() {}
 
 DownloadsOpenFunction::~DownloadsOpenFunction() {}
 
 bool DownloadsOpenFunction::RunSync() {
-  scoped_ptr<downloads::Open::Params> params(
+  std::unique_ptr<downloads::Open::Params> params(
       downloads::Open::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(!user_gesture(), errors::kUserGesture, &error_) ||
       Fault(download_item->GetState() != DownloadItem::COMPLETE,
             errors::kNotComplete,
             &error_) ||
       Fault(!extension()->permissions_data()->HasAPIPermission(
                 APIPermission::kDownloadsOpen),
             errors::kOpenPermission,
             &error_))
     return false;
   download_item->OpenDownload();
   RecordApiFunctions(DOWNLOADS_FUNCTION_OPEN);
   return true;
 }
 
 DownloadsDragFunction::DownloadsDragFunction() {}
 
 DownloadsDragFunction::~DownloadsDragFunction() {}
 
 bool DownloadsDragFunction::RunAsync() {
-  scoped_ptr<downloads::Drag::Params> params(
+  std::unique_ptr<downloads::Drag::Params> params(
       downloads::Drag::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   content::WebContents* web_contents =
       dispatcher()->GetVisibleWebContents();
   if (InvalidId(download_item, &error_) ||
       Fault(!web_contents, errors::kInvisibleContext, &error_))
     return false;
   RecordApiFunctions(DOWNLOADS_FUNCTION_DRAG);
   gfx::Image* icon = g_browser_process->icon_manager()->LookupIconFromFilepath(
       download_item->GetTargetFilePath(), IconLoader::NORMAL);
   gfx::NativeView view = web_contents->GetNativeView();
   {
     // Enable nested tasks during DnD, while |DragDownload()| blocks.
     base::MessageLoop::ScopedNestableTaskAllower allow(
         base::MessageLoop::current());
     DragDownloadItem(download_item, icon, view);
   }
   return true;
 }
 
 DownloadsSetShelfEnabledFunction::DownloadsSetShelfEnabledFunction() {}
 
 DownloadsSetShelfEnabledFunction::~DownloadsSetShelfEnabledFunction() {}
 
 bool DownloadsSetShelfEnabledFunction::RunSync() {
-  scoped_ptr<downloads::SetShelfEnabled::Params> params(
+  std::unique_ptr<downloads::SetShelfEnabled::Params> params(
       downloads::SetShelfEnabled::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (!extension()->permissions_data()->HasAPIPermission(
           APIPermission::kDownloadsShelf)) {
     error_ = download_extension_errors::kShelfPermission;
     return false;
   }
 
   RecordApiFunctions(DOWNLOADS_FUNCTION_SET_SHELF_ENABLED);
   DownloadManager* manager = NULL;
@@ skipping 45 matching lines @@
 
 DownloadsGetFileIconFunction::~DownloadsGetFileIconFunction() {}
 
 void DownloadsGetFileIconFunction::SetIconExtractorForTesting(
     DownloadFileIconExtractor* extractor) {
   DCHECK(extractor);
   icon_extractor_.reset(extractor);
 }
 
 bool DownloadsGetFileIconFunction::RunAsync() {
-  scoped_ptr<downloads::GetFileIcon::Params> params(
+  std::unique_ptr<downloads::GetFileIcon::Params> params(
       downloads::GetFileIcon::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const downloads::GetFileIconOptions* options =
       params->options.get();
   int icon_size = kDefaultIconSize;
   if (options && options->size.get())
     icon_size = *options->size.get();
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
@@ skipping 271 matching lines @@
   EventRouter* router = EventRouter::Get(profile_);
   // Avoid allocating a bunch of memory in DownloadItemToJSON if it isn't going
   // to be used.
   if (!router ||
       (!router->HasEventListener(downloads::OnCreated::kEventName) &&
        !router->HasEventListener(downloads::OnChanged::kEventName) &&
        !router->HasEventListener(
             downloads::OnDeterminingFilename::kEventName))) {
     return;
   }
-  scoped_ptr<base::DictionaryValue> json_item(
+  std::unique_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item, profile_));
   DispatchEvent(events::DOWNLOADS_ON_CREATED, downloads::OnCreated::kEventName,
                 true, Event::WillDispatchCallback(), json_item->DeepCopy());
   if (!ExtensionDownloadsEventRouterData::Get(download_item) &&
       (router->HasEventListener(downloads::OnChanged::kEventName) ||
        router->HasEventListener(
            downloads::OnDeterminingFilename::kEventName))) {
     new ExtensionDownloadsEventRouterData(download_item, std::move(json_item));
   }
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   EventRouter* router = EventRouter::Get(profile_);
   ExtensionDownloadsEventRouterData* data =
     ExtensionDownloadsEventRouterData::Get(download_item);
   if (download_item->IsTemporary() ||
       !router->HasEventListener(downloads::OnChanged::kEventName)) {
     return;
   }
   if (!data) {
     // The download_item probably transitioned from temporary to not temporary,
     // or else an event listener was added.
     data = new ExtensionDownloadsEventRouterData(
         download_item,
-        scoped_ptr<base::DictionaryValue>(new base::DictionaryValue()));
+        std::unique_ptr<base::DictionaryValue>(new base::DictionaryValue()));
   }
-  scoped_ptr<base::DictionaryValue> new_json(DownloadItemToJSON(
-      download_item, profile_));
-  scoped_ptr<base::DictionaryValue> delta(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> new_json(
+      DownloadItemToJSON(download_item, profile_));
+  std::unique_ptr<base::DictionaryValue> delta(new base::DictionaryValue());
   delta->SetInteger(kIdKey, download_item->GetId());
   std::set<std::string> new_fields;
   bool changed = false;
 
   // For each field in the new json representation of the download_item except
   // the bytesReceived field, if the field has changed from the previous old
   // json, set the differences in the |delta| object and remember that something
   // significant changed.
   for (base::DictionaryValue::Iterator iter(*new_json.get());
        !iter.IsAtEnd(); iter.Advance()) {
@@ skipping 48 matching lines @@
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     events::HistogramValue histogram_value,
     const std::string& event_name,
     bool include_incognito,
     const Event::WillDispatchCallback& will_dispatch_callback,
     base::Value* arg) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!EventRouter::Get(profile_))
     return;
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   std::string json_args;
   base::JSONWriter::Write(*args, &json_args);
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(histogram_value, event_name, std::move(args)));
   // The downloads system wants to share on-record events with off-record
   // extension renderers even in incognito_split_mode because that's how
   // chrome://downloads works. The "restrict_to_profile" mechanism does not
   // anticipate this, so it does not automatically prevent sharing off-record
   // events with on-record extension renderers.
   event->restrict_to_browser_context =
       (include_incognito && !profile_->IsOffTheRecord()) ? NULL : profile_;
   event->will_dispatch_callback = will_dispatch_callback;
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
@@ skipping 26 matching lines @@
     return;
   base::Time now(base::Time::Now());
   int delta = now.ToTimeT() - last_checked_removal_.ToTimeT();
   if (delta <= kFileExistenceRateLimitSeconds)
     return;
   last_checked_removal_ = now;
   manager->CheckForHistoryFilesRemoval();
 }
 
 }  // namespace extensions