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

chrome/browser/extensions/api/tabs/tabs_event_router.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/tabs/tabs_event_router.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/values.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_windows_api.h"
 #include "chrome/browser/extensions/api/tabs/windows_event_router.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 47 matching lines @@
       was_muted_(contents->IsAudioMuted()),
       router_(router) {}
 
 scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::UpdateLoadState() {
   // The tab may go in & out of loading (for instance if iframes navigate).
   // We only want to respond to the first change from loading to !loading after
   // the NavigationEntryCommitted() was fired.
   scoped_ptr<base::DictionaryValue> changed_properties(
       new base::DictionaryValue());
   if (!complete_waiting_on_load_ || web_contents()->IsLoading()) {
-    return changed_properties.Pass();
+    return changed_properties;
   }
 
   // Send "complete" state change.
   complete_waiting_on_load_ = false;
   changed_properties->SetString(tabs_constants::kStatusKey,
                                 tabs_constants::kStatusValueComplete);
-  return changed_properties.Pass();
+  return changed_properties;
 }
 
 scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::DidNavigate() {
   // Send "loading" state change.
   complete_waiting_on_load_ = true;
   scoped_ptr<base::DictionaryValue> changed_properties(
       new base::DictionaryValue());
   changed_properties->SetString(tabs_constants::kStatusKey,
                                 tabs_constants::kStatusValueLoading);
 
   if (web_contents()->GetURL() != url_) {
     url_ = web_contents()->GetURL();
     changed_properties->SetString(tabs_constants::kUrlKey, url_.spec());
   }
 
-  return changed_properties.Pass();
+  return changed_properties;
 }
 
 scoped_ptr<base::DictionaryValue> TabsEventRouter::TabEntry::TitleChanged() {
   scoped_ptr<base::DictionaryValue> changed_properties(
       new base::DictionaryValue());
   changed_properties->SetString(tabs_constants::kTitleKey,
                                 web_contents()->GetTitle());
-  return changed_properties.Pass();
+  return changed_properties;
 }
 
 bool TabsEventRouter::TabEntry::SetAudible(bool new_val) {
   if (was_audible_ == new_val)
     return false;
   was_audible_ = new_val;
   return true;
 }
 
 bool TabsEventRouter::TabEntry::SetMuted(bool new_val) {
@@ skipping 83 matching lines @@
   event->event_args->Append(tab_value);
   tab_value->SetBoolean(tabs_constants::kSelectedKey, active);
   return true;
 }
 
 void TabsEventRouter::TabCreatedAt(WebContents* contents,
                                    int index,
                                    bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   scoped_ptr<base::ListValue> args(new base::ListValue);
-  scoped_ptr<Event> event(new Event(events::TABS_ON_CREATED,
-                                    tabs::OnCreated::kEventName, args.Pass()));
+  scoped_ptr<Event> event(new Event(
+      events::TABS_ON_CREATED, tabs::OnCreated::kEventName, std::move(args)));
   event->restrict_to_browser_context = profile;
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
   event->will_dispatch_callback =
       base::Bind(&WillDispatchTabCreatedEvent, contents, active);
-  EventRouter::Get(profile)->BroadcastEvent(event.Pass());
+  EventRouter::Get(profile)->BroadcastEvent(std::move(event));
 
   RegisterForTabNotifications(contents);
 }
 
 void TabsEventRouter::TabInsertedAt(WebContents* contents,
                                     int index,
                                     bool active) {
   if (!GetTabEntry(contents)) {
     // We've never seen this tab, send create event as long as we're not in the
     // constructor.
@@ skipping 11 matching lines @@
   base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->Set(tabs_constants::kNewWindowIdKey,
                    new FundamentalValue(
                        ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tabs_constants::kNewPositionKey,
                    new FundamentalValue(index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_ATTACHED, tabs::OnAttached::kEventName,
-                args.Pass(), EventRouter::USER_GESTURE_UNKNOWN);
+                std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabDetachedAt(WebContents* contents, int index) {
   if (!GetTabEntry(contents)) {
     // The tab was removed. Don't send detach event.
     return;
   }
 
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(
       new FundamentalValue(ExtensionTabUtil::GetTabId(contents)));
 
   base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->Set(tabs_constants::kOldWindowIdKey,
                    new FundamentalValue(
                        ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tabs_constants::kOldPositionKey,
                    new FundamentalValue(index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_DETACHED, tabs::OnDetached::kEventName,
-                args.Pass(), EventRouter::USER_GESTURE_UNKNOWN);
+                std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabClosingAt(TabStripModel* tab_strip_model,
                                    WebContents* contents,
                                    int index) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
 
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(new FundamentalValue(tab_id));
 
   base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->SetInteger(tabs_constants::kWindowIdKey,
                           ExtensionTabUtil::GetWindowIdOfTab(contents));
   object_args->SetBoolean(tabs_constants::kWindowClosing,
                           tab_strip_model->closing_all());
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_REMOVED, tabs::OnRemoved::kEventName,
-                args.Pass(), EventRouter::USER_GESTURE_UNKNOWN);
+                std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 
   UnregisterForTabNotifications(contents);
 }
 
 void TabsEventRouter::ActiveTabChanged(WebContents* old_contents,
                                        WebContents* new_contents,
                                        int index,
                                        int reason) {
   scoped_ptr<base::ListValue> args(new base::ListValue);
   int tab_id = ExtensionTabUtil::GetTabId(new_contents);
@@ skipping 18 matching lines @@
                 scoped_ptr<base::ListValue>(args->DeepCopy()), gesture);
   DispatchEvent(profile, events::TABS_ON_ACTIVE_CHANGED,
                 tabs::OnActiveChanged::kEventName,
                 scoped_ptr<base::ListValue>(args->DeepCopy()), gesture);
 
   // The onActivated event takes one argument: {windowId, tabId}.
   args->Remove(0, NULL);
   object_args->Set(tabs_constants::kTabIdKey,
                    new FundamentalValue(tab_id));
   DispatchEvent(profile, events::TABS_ON_ACTIVATED,
-                tabs::OnActivated::kEventName, args.Pass(), gesture);
+                tabs::OnActivated::kEventName, std::move(args), gesture);
 }
 
 void TabsEventRouter::TabSelectionChanged(
     TabStripModel* tab_strip_model,
     const ui::ListSelectionModel& old_model) {
   ui::ListSelectionModel::SelectedIndices new_selection =
       tab_strip_model->selection_model().selected_indices();
   scoped_ptr<base::ListValue> all_tabs(new base::ListValue);
 
   for (size_t i = 0; i < new_selection.size(); ++i) {
@@ skipping 16 matching lines @@
   select_info->Set(tabs_constants::kTabIdsKey, all_tabs.release());
   args->Append(select_info.release());
 
   // The onHighlighted event replaced onHighlightChanged.
   Profile* profile = tab_strip_model->profile();
   DispatchEvent(profile, events::TABS_ON_HIGHLIGHT_CHANGED,
                 tabs::OnHighlightChanged::kEventName,
                 scoped_ptr<base::ListValue>(args->DeepCopy()),
                 EventRouter::USER_GESTURE_UNKNOWN);
   DispatchEvent(profile, events::TABS_ON_HIGHLIGHTED,
-                tabs::OnHighlighted::kEventName, args.Pass(),
+                tabs::OnHighlighted::kEventName, std::move(args),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabMoved(WebContents* contents,
                                int from_index,
                                int to_index) {
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(
       new FundamentalValue(ExtensionTabUtil::GetTabId(contents)));
 
   base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->Set(tabs_constants::kWindowIdKey,
                    new FundamentalValue(
                        ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tabs_constants::kFromIndexKey,
                    new FundamentalValue(from_index));
   object_args->Set(tabs_constants::kToIndexKey,
                    new FundamentalValue(to_index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_MOVED, tabs::OnMoved::kEventName,
-                args.Pass(), EventRouter::USER_GESTURE_UNKNOWN);
+                std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabUpdated(
     TabEntry* entry,
     scoped_ptr<base::DictionaryValue> changed_properties) {
   CHECK(entry->web_contents());
 
   bool audible = entry->web_contents()->WasRecentlyAudible();
   if (entry->SetAudible(audible)) {
     changed_properties->SetBoolean(tabs_constants::kAudibleKey, audible);
   }
 
   bool muted = entry->web_contents()->IsAudioMuted();
   if (entry->SetMuted(muted)) {
     changed_properties->Set(
         tabs_constants::kMutedInfoKey,
-        ExtensionTabUtil::CreateMutedInfo(entry->web_contents()).Pass());
+        ExtensionTabUtil::CreateMutedInfo(entry->web_contents()));
   }
 
   if (!changed_properties->empty()) {
-    DispatchTabUpdatedEvent(entry->web_contents(), changed_properties.Pass());
+    DispatchTabUpdatedEvent(entry->web_contents(),
+                            std::move(changed_properties));
   }
 }
 
 void TabsEventRouter::FaviconUrlUpdated(WebContents* contents) {
     content::NavigationEntry* entry =
         contents->GetController().GetVisibleEntry();
     if (!entry || !entry->GetFavicon().valid)
       return;
     scoped_ptr<base::DictionaryValue> changed_properties(
         new base::DictionaryValue);
     changed_properties->SetString(
         tabs_constants::kFaviconUrlKey,
         entry->GetFavicon().url.possibly_invalid_spec());
-    DispatchTabUpdatedEvent(contents, changed_properties.Pass());
+    DispatchTabUpdatedEvent(contents, std::move(changed_properties));
 }
 
 void TabsEventRouter::DispatchEvent(
     Profile* profile,
     events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> args,
     EventRouter::UserGestureState user_gesture) {
   EventRouter* event_router = EventRouter::Get(profile);
   if (!profile_->IsSameProfile(profile) || !event_router)
     return;
 
-  scoped_ptr<Event> event(new Event(histogram_value, event_name, args.Pass()));
+  scoped_ptr<Event> event(
+      new Event(histogram_value, event_name, std::move(args)));
   event->restrict_to_browser_context = profile;
   event->user_gesture = user_gesture;
-  event_router->BroadcastEvent(event.Pass());
+  event_router->BroadcastEvent(std::move(event));
 }
 
 void TabsEventRouter::DispatchTabUpdatedEvent(
     WebContents* contents,
     scoped_ptr<base::DictionaryValue> changed_properties) {
   DCHECK(changed_properties);
   DCHECK(contents);
 
   // The state of the tab (as seen from the extension point of view) has
   // changed.  Send a notification to the extension.
   scoped_ptr<base::ListValue> args_base(new base::ListValue);
 
   // First arg: The id of the tab that changed.
   args_base->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 
   // Second arg: An object containing the changes to the tab state.  Filled in
   // by WillDispatchTabUpdatedEvent as a copy of changed_properties, if the
   // extension has the tabs permission.
 
   // Third arg: An object containing the state of the tab. Filled in by
   // WillDispatchTabUpdatedEvent.
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 
-  scoped_ptr<Event> event(new Event(
-      events::TABS_ON_UPDATED, tabs::OnUpdated::kEventName, args_base.Pass()));
+  scoped_ptr<Event> event(new Event(events::TABS_ON_UPDATED,
+                                    tabs::OnUpdated::kEventName,
+                                    std::move(args_base)));
   event->restrict_to_browser_context = profile;
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
   event->will_dispatch_callback =
       base::Bind(&WillDispatchTabUpdatedEvent,
                  contents,
                  changed_properties.get());
-  EventRouter::Get(profile)->BroadcastEvent(event.Pass());
+  EventRouter::Get(profile)->BroadcastEvent(std::move(event));
 }
 
 TabsEventRouter::TabEntry* TabsEventRouter::GetTabEntry(WebContents* contents) {
   const auto it = tab_entries_.find(ExtensionTabUtil::GetTabId(contents));
 
   return it == tab_entries_.end() ? nullptr : it->second.get();
 }
 
 void TabsEventRouter::TabChangedAt(WebContents* contents,
                                    int index,
@@ skipping 10 matching lines @@
   // Notify listeners that the next tabs closing or being added are due to
   // WebContents being swapped.
   const int new_tab_id = ExtensionTabUtil::GetTabId(new_contents);
   const int old_tab_id = ExtensionTabUtil::GetTabId(old_contents);
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(new FundamentalValue(new_tab_id));
   args->Append(new FundamentalValue(old_tab_id));
 
   DispatchEvent(Profile::FromBrowserContext(new_contents->GetBrowserContext()),
                 events::TABS_ON_REPLACED, tabs::OnReplaced::kEventName,
-                args.Pass(), EventRouter::USER_GESTURE_UNKNOWN);
+                std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 
   UnregisterForTabNotifications(old_contents);
 
   if (!GetTabEntry(new_contents))
     RegisterForTabNotifications(new_contents);
 }
 
 void TabsEventRouter::TabPinnedStateChanged(WebContents* contents, int index) {
   TabStripModel* tab_strip = NULL;
   int tab_index;
 
   if (ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index)) {
     scoped_ptr<base::DictionaryValue> changed_properties(
         new base::DictionaryValue());
     changed_properties->SetBoolean(tabs_constants::kPinnedKey,
                                    tab_strip->IsTabPinned(tab_index));
-    DispatchTabUpdatedEvent(contents, changed_properties.Pass());
+    DispatchTabUpdatedEvent(contents, std::move(changed_properties));
   }
 }
 
 void TabsEventRouter::OnZoomChanged(
     const ZoomController::ZoomChangedEventData& data) {
   DCHECK(data.web_contents);
   int tab_id = ExtensionTabUtil::GetTabId(data.web_contents);
   if (tab_id < 0)
     return;
 
@@ skipping 23 matching lines @@
     bool icon_url_changed,
     const gfx::Image& image) {
   if (notification_icon_type == NON_TOUCH_16_DIP && icon_url_changed) {
     favicon::ContentFaviconDriver* content_favicon_driver =
         static_cast<favicon::ContentFaviconDriver*>(favicon_driver);
     FaviconUrlUpdated(content_favicon_driver->web_contents());
   }
 }
 
 }  // namespace extensions