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

chrome/browser/extensions/api/bookmarks/bookmarks_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/bookmarks/bookmarks_api.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
@@ skipping 224 matching lines @@
 
 BookmarkEventRouter::~BookmarkEventRouter() {
   if (model_) {
     model_->RemoveObserver(this);
   }
 }
 
 void BookmarkEventRouter::DispatchEvent(
     events::HistogramValue histogram_value,
     const std::string& event_name,
-    scoped_ptr<base::ListValue> event_args) {
+    std::unique_ptr<base::ListValue> event_args) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (event_router) {
-    event_router->BroadcastEvent(make_scoped_ptr(new extensions::Event(
+    event_router->BroadcastEvent(base::WrapUnique(new extensions::Event(
         histogram_value, event_name, std::move(event_args))));
   }
 }
 
 void BookmarkEventRouter::BookmarkModelLoaded(BookmarkModel* model,
                                               bool ids_reassigned) {
   // TODO(erikkay): Perhaps we should send this event down to the extension
   // so they know when it's safe to use the API?
 }
 
@@ skipping 135 matching lines @@
   return g_factory.Pointer();
 }
 
 void BookmarksAPI::OnListenerAdded(const EventListenerInfo& details) {
   bookmark_event_router_.reset(
       new BookmarkEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 bool BookmarksGetFunction::RunOnReady() {
-  scoped_ptr<bookmarks::Get::Params> params(
+  std::unique_ptr<bookmarks::Get::Params> params(
       bookmarks::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<BookmarkTreeNode> nodes;
   ManagedBookmarkService* managed = GetManagedBookmarkService();
   if (params->id_or_id_list.as_strings) {
     std::vector<std::string>& ids = *params->id_or_id_list.as_strings;
     size_t count = ids.size();
     EXTENSION_FUNCTION_VALIDATE(count > 0);
     for (size_t i = 0; i < count; ++i) {
       const BookmarkNode* node = GetBookmarkNodeFromId(ids[i]);
       if (!node)
         return false;
       bookmark_api_helpers::AddNode(managed, node, &nodes, false);
     }
   } else {
     const BookmarkNode* node =
         GetBookmarkNodeFromId(*params->id_or_id_list.as_string);
     if (!node)
       return false;
     bookmark_api_helpers::AddNode(managed, node, &nodes, false);
   }
 
   results_ = bookmarks::Get::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksGetChildrenFunction::RunOnReady() {
-  scoped_ptr<bookmarks::GetChildren::Params> params(
+  std::unique_ptr<bookmarks::GetChildren::Params> params(
       bookmarks::GetChildren::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   std::vector<BookmarkTreeNode> nodes;
   int child_count = node->child_count();
   for (int i = 0; i < child_count; ++i) {
     const BookmarkNode* child = node->GetChild(i);
     bookmark_api_helpers::AddNode(GetManagedBookmarkService(), child, &nodes,
                                   false);
   }
 
   results_ = bookmarks::GetChildren::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksGetRecentFunction::RunOnReady() {
-  scoped_ptr<bookmarks::GetRecent::Params> params(
+  std::unique_ptr<bookmarks::GetRecent::Params> params(
       bookmarks::GetRecent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->number_of_items < 1)
     return false;
 
   std::vector<const BookmarkNode*> nodes;
   ::bookmarks::GetMostRecentlyAddedEntries(
       BookmarkModelFactory::GetForProfile(GetProfile()),
       params->number_of_items,
       &nodes);
@@ skipping 12 matching lines @@
   std::vector<BookmarkTreeNode> nodes;
   const BookmarkNode* node =
       BookmarkModelFactory::GetForProfile(GetProfile())->root_node();
   bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node, &nodes,
                                 true);
   results_ = bookmarks::GetTree::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksGetSubTreeFunction::RunOnReady() {
-  scoped_ptr<bookmarks::GetSubTree::Params> params(
+  std::unique_ptr<bookmarks::GetSubTree::Params> params(
       bookmarks::GetSubTree::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   std::vector<BookmarkTreeNode> nodes;
   bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node, &nodes,
                                 true);
   results_ = bookmarks::GetSubTree::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksSearchFunction::RunOnReady() {
-  scoped_ptr<bookmarks::Search::Params> params(
+  std::unique_ptr<bookmarks::Search::Params> params(
       bookmarks::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<const BookmarkNode*> nodes;
   if (params->query.as_string) {
     ::bookmarks::QueryFields query;
     query.word_phrase_query.reset(
         new base::string16(base::UTF8ToUTF16(*params->query.as_string)));
     ::bookmarks::GetBookmarksMatchingProperties(
         BookmarkModelFactory::GetForProfile(GetProfile()),
@@ skipping 41 matching lines @@
     ids->push_back(id);
   else
     *invalid_id = true;
   return true;
 }
 
 bool BookmarksRemoveFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
-  scoped_ptr<bookmarks::Remove::Params> params(
+  std::unique_ptr<bookmarks::Remove::Params> params(
       bookmarks::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64_t id;
   if (!GetBookmarkIdAsInt64(params->id, &id))
     return false;
 
   bool recursive = false;
   if (name() == BookmarksRemoveTreeFunction::function_name())
     recursive = true;
 
   BookmarkModel* model = GetBookmarkModel();
   ManagedBookmarkService* managed = GetManagedBookmarkService();
   if (!bookmark_api_helpers::RemoveNode(model, managed, id, recursive, &error_))
     return false;
 
   return true;
 }
 
 bool BookmarksCreateFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
-  scoped_ptr<bookmarks::Create::Params> params(
+  std::unique_ptr<bookmarks::Create::Params> params(
       bookmarks::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
   const BookmarkNode* node = CreateBookmarkNode(model, params->bookmark, NULL);
   if (!node)
     return false;
 
   BookmarkTreeNode ret = bookmark_api_helpers::GetBookmarkTreeNode(
       GetManagedBookmarkService(), node, false, false);
   results_ = bookmarks::Create::Results::Create(ret);
 
   return true;
 }
 
 // static
 bool BookmarksMoveFunction::ExtractIds(const base::ListValue* args,
                                        std::list<int64_t>* ids,
                                        bool* invalid_id) {
   // For now, Move accepts ID parameters in the same way as an Update.
   return BookmarksUpdateFunction::ExtractIds(args, ids, invalid_id);
 }
 
 bool BookmarksMoveFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
-  scoped_ptr<bookmarks::Move::Params> params(
+  std::unique_ptr<bookmarks::Move::Params> params(
       bookmarks::Move::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
   if (model->is_permanent_node(node)) {
     error_ = keys::kModifySpecialError;
@@ skipping 39 matching lines @@
                                          std::list<int64_t>* ids,
                                          bool* invalid_id) {
   // For now, Update accepts ID parameters in the same way as an Remove.
   return BookmarksRemoveFunction::ExtractIds(args, ids, invalid_id);
 }
 
 bool BookmarksUpdateFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
-  scoped_ptr<bookmarks::Update::Params> params(
+  std::unique_ptr<bookmarks::Update::Params> params(
       bookmarks::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Optional but we need to distinguish non present from an empty title.
   base::string16 title;
   bool has_title = false;
   if (params->changes.title.get()) {
     title = base::UTF8ToUTF16(*params->changes.title);
     has_title = true;
   }
@@ skipping 134 matching lines @@
 }
 
 void BookmarksExportFunction::FileSelected(const base::FilePath& path,
                                            int index,
                                            void* params) {
   bookmark_html_writer::WriteBookmarks(GetProfile(), path, NULL);
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions