Convert Pass()→std::move() in //chrome/browser/extensions

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 <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/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 47 matching lines @@
   scoped_ptr<HistoryItem> history_item(new HistoryItem());
 
   history_item->id = base::Int64ToString(row.id());
   history_item->url.reset(new std::string(row.url().spec()));
   history_item->title.reset(new std::string(base::UTF16ToUTF8(row.title())));
   history_item->last_visit_time.reset(
       new double(MilliSecondsFromTime(row.last_visit())));
   history_item->typed_count.reset(new int(row.typed_count()));
   history_item->visit_count.reset(new int(row.visit_count()));
 
-  return history_item.Pass();
+  return history_item;
 }
 
 scoped_ptr<VisitItem> GetVisitItem(const history::VisitRow& row) {
   scoped_ptr<VisitItem> visit_item(new VisitItem());
 
   visit_item->id = base::Int64ToString(row.url_id);
   visit_item->visit_id = base::Int64ToString(row.visit_id);
   visit_item->visit_time.reset(
       new double(MilliSecondsFromTime(row.visit_time)));
   visit_item->referring_visit_id = base::Int64ToString(row.referring_visit);
@@ skipping 32 matching lines @@
       break;
     case ui::PAGE_TRANSITION_KEYWORD_GENERATED:
       transition = api::history::TRANSITION_TYPE_KEYWORD_GENERATED;
       break;
     default:
       DCHECK(false);
   }
 
   visit_item->transition = transition;
 
-  return visit_item.Pass();
+  return visit_item;
 }
 
 }  // namespace
 
 HistoryEventRouter::HistoryEventRouter(Profile* profile,
                                        history::HistoryService* history_service)
     : profile_(profile), history_service_observer_(this) {
   DCHECK(profile);
   history_service_observer_.Add(history_service);
 }
 
 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<HistoryItem> history_item = GetHistoryItem(row);
   scoped_ptr<base::ListValue> args = OnVisited::Create(*history_item);
   DispatchEvent(profile_, events::HISTORY_ON_VISITED,
-                api::history::OnVisited::kEventName, args.Pass());
+                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);
   DispatchEvent(profile_, events::HISTORY_ON_VISIT_REMOVED,
-                api::history::OnVisitRemoved::kEventName, args.Pass());
+                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) {
   if (profile && EventRouter::Get(profile)) {
     scoped_ptr<Event> event(
-        new Event(histogram_value, event_name, event_args.Pass()));
+        new Event(histogram_value, event_name, std::move(event_args)));
     event->restrict_to_browser_context = profile;
-    EventRouter::Get(profile)->BroadcastEvent(event.Pass());
+    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);
   event_router->RegisterObserver(this,
                                  api::history::OnVisitRemoved::kEventName);
 }
@@ skipping 267 matching lines @@
   }
 
   return true;
 }
 
 void HistoryDeleteAllFunction::DeleteComplete() {
   SendAsyncResponse();
 }
 
 }  // namespace extensions