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

chrome/browser/extensions/api/sessions/sessions_api.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/sessions/sessions_api.h"
 
 #include <stddef.h>
+
 #include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/extensions/api/sessions/session_id.h"
 #include "chrome/browser/extensions/api/tabs/windows_util.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/extensions/window_controller_list.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 76 matching lines @@
   // Note: |selected_index| from the sync sessions model is what we call
   // "active" in extensions terminology.  "selected" is deprecated because it's
   // not clear whether it means "active" (user can see) or "highlighted" (user
   // has highlighted, since you can select tabs without bringing them into the
   // foreground).
   tab_struct.active = index == selected_index;
   ExtensionTabUtil::ScrubTabForExtension(extension, nullptr, &tab_struct);
   return tab_struct;
 }
 
-scoped_ptr<windows::Window> CreateWindowModelHelper(
-    scoped_ptr<std::vector<tabs::Tab>> tabs,
+std::unique_ptr<windows::Window> CreateWindowModelHelper(
+    std::unique_ptr<std::vector<tabs::Tab>> tabs,
     const std::string& session_id,
     const windows::WindowType& type,
     const windows::WindowState& state) {
-  scoped_ptr<windows::Window> window_struct(new windows::Window);
+  std::unique_ptr<windows::Window> window_struct(new windows::Window);
   window_struct->tabs = std::move(tabs);
   window_struct->session_id.reset(new std::string(session_id));
   window_struct->incognito = false;
   window_struct->always_on_top = false;
   window_struct->focused = false;
   window_struct->type = type;
   window_struct->state = state;
   return window_struct;
 }
 
-scoped_ptr<api::sessions::Session> CreateSessionModelHelper(
+std::unique_ptr<api::sessions::Session> CreateSessionModelHelper(
     int last_modified,
-    scoped_ptr<tabs::Tab> tab,
-    scoped_ptr<windows::Window> window) {
-  scoped_ptr<api::sessions::Session> session_struct(
+    std::unique_ptr<tabs::Tab> tab,
+    std::unique_ptr<windows::Window> window) {
+  std::unique_ptr<api::sessions::Session> session_struct(
       new api::sessions::Session());
   session_struct->last_modified = last_modified;
   if (tab)
     session_struct->tab = std::move(tab);
   else if (window)
     session_struct->window = std::move(window);
   else
     NOTREACHED();
   return session_struct;
 }
@@ skipping 12 matching lines @@
     int selected_index) {
   return CreateTabModelHelper(GetProfile(),
                               tab.navigations[tab.current_navigation_index],
                               base::IntToString(session_id),
                               tab.tabstrip_index,
                               tab.pinned,
                               selected_index,
                               extension());
 }
 
-scoped_ptr<windows::Window>
+std::unique_ptr<windows::Window>
 SessionsGetRecentlyClosedFunction::CreateWindowModel(
     const sessions::TabRestoreService::Window& window,
     int session_id) {
   DCHECK(!window.tabs.empty());
 
-  scoped_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
+  std::unique_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     tabs->push_back(CreateTabModel(window.tabs[i], window.tabs[i].id,
                                    window.selected_tab_index));
   }
 
   return CreateWindowModelHelper(std::move(tabs), base::IntToString(session_id),
                                  windows::WINDOW_TYPE_NORMAL,
                                  windows::WINDOW_STATE_NORMAL);
 }
 
-scoped_ptr<api::sessions::Session>
+std::unique_ptr<api::sessions::Session>
 SessionsGetRecentlyClosedFunction::CreateSessionModel(
     const sessions::TabRestoreService::Entry* entry) {
-  scoped_ptr<tabs::Tab> tab;
-  scoped_ptr<windows::Window> window;
+  std::unique_ptr<tabs::Tab> tab;
+  std::unique_ptr<windows::Window> window;
   switch (entry->type) {
     case sessions::TabRestoreService::TAB:
       tab.reset(new tabs::Tab(CreateTabModel(
           *static_cast<const sessions::TabRestoreService::Tab*>(entry),
           entry->id, -1)));
       break;
     case sessions::TabRestoreService::WINDOW:
       window = CreateWindowModel(
           *static_cast<const sessions::TabRestoreService::Window*>(entry),
           entry->id);
       break;
     default:
       NOTREACHED();
   }
   return CreateSessionModelHelper(entry->timestamp.ToTimeT(), std::move(tab),
                                   std::move(window));
 }
 
 bool SessionsGetRecentlyClosedFunction::RunSync() {
-  scoped_ptr<GetRecentlyClosed::Params> params(
+  std::unique_ptr<GetRecentlyClosed::Params> params(
       GetRecentlyClosed::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   int max_results = api::sessions::MAX_SESSION_RESULTS;
   if (params->filter && params->filter->max_results)
     max_results = *params->filter->max_results;
   EXTENSION_FUNCTION_VALIDATE(max_results >= 0 &&
       max_results <= api::sessions::MAX_SESSION_RESULTS);
 
   std::vector<api::sessions::Session> result;
   sessions::TabRestoreService* tab_restore_service =
@@ skipping 29 matching lines @@
   return CreateTabModelHelper(
       GetProfile(),
       tab.navigations[tab.normalized_navigation_index()],
       session_id,
       tab_index,
       tab.pinned,
       selected_index,
       extension());
 }
 
-scoped_ptr<windows::Window> SessionsGetDevicesFunction::CreateWindowModel(
-        const sessions::SessionWindow& window, const std::string& session_tag) {
+std::unique_ptr<windows::Window> SessionsGetDevicesFunction::CreateWindowModel(
+    const sessions::SessionWindow& window,
+    const std::string& session_tag) {
   DCHECK(!window.tabs.empty());
 
   // Prune tabs that are not syncable or are NewTabPage. Then, sort the tabs
   // from most recent to least recent.
   std::vector<const sessions::SessionTab*> tabs_in_window;
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     const sessions::SessionTab* tab = window.tabs[i];
     if (tab->navigations.empty())
       continue;
     const sessions::SerializedNavigationEntry& current_navigation =
         tab->navigations.at(tab->normalized_navigation_index());
     if (search::IsNTPURL(current_navigation.virtual_url(), GetProfile())) {
       continue;
     }
     tabs_in_window.push_back(tab);
   }
   if (tabs_in_window.empty())
-    return scoped_ptr<windows::Window>();
+    return std::unique_ptr<windows::Window>();
   std::sort(tabs_in_window.begin(), tabs_in_window.end(), SortTabsByRecency);
 
-  scoped_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
+  std::unique_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
   for (size_t i = 0; i < tabs_in_window.size(); ++i) {
     tabs->push_back(CreateTabModel(session_tag, *tabs_in_window[i], i,
                                    window.selected_tab_index));
   }
 
   std::string session_id =
       SessionId(session_tag, window.window_id.id()).ToString();
 
   windows::WindowType type = windows::WINDOW_TYPE_NONE;
   switch (window.type) {
@@ skipping 19 matching lines @@
       break;
     case ui::SHOW_STATE_FULLSCREEN:
       state = windows::WINDOW_STATE_FULLSCREEN;
       break;
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_INACTIVE:
     case ui::SHOW_STATE_END:
       break;
   }
 
-  scoped_ptr<windows::Window> window_struct(
+  std::unique_ptr<windows::Window> window_struct(
       CreateWindowModelHelper(std::move(tabs), session_id, type, state));
   // TODO(dwankri): Dig deeper to resolve bounds not being optional, so closed
   // windows in GetRecentlyClosed can have set values in Window helper.
   window_struct->left.reset(new int(window.bounds.x()));
   window_struct->top.reset(new int(window.bounds.y()));
   window_struct->width.reset(new int(window.bounds.width()));
   window_struct->height.reset(new int(window.bounds.height()));
 
   return window_struct;
 }
 
-scoped_ptr<api::sessions::Session>
+std::unique_ptr<api::sessions::Session>
 SessionsGetDevicesFunction::CreateSessionModel(
-    const sessions::SessionWindow& window, const std::string& session_tag) {
-  scoped_ptr<windows::Window> window_model(
+    const sessions::SessionWindow& window,
+    const std::string& session_tag) {
+  std::unique_ptr<windows::Window> window_model(
       CreateWindowModel(window, session_tag));
   // There is a chance that after pruning uninteresting tabs the window will be
   // empty.
-  return !window_model ? scoped_ptr<api::sessions::Session>()
+  return !window_model ? std::unique_ptr<api::sessions::Session>()
                        : CreateSessionModelHelper(window.timestamp.ToTimeT(),
-                                                  scoped_ptr<tabs::Tab>(),
+                                                  std::unique_ptr<tabs::Tab>(),
                                                   std::move(window_model));
 }
 
 api::sessions::Device SessionsGetDevicesFunction::CreateDeviceModel(
     const sync_driver::SyncedSession* session) {
   int max_results = api::sessions::MAX_SESSION_RESULTS;
   // Already validated in RunAsync().
-  scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
+  std::unique_ptr<GetDevices::Params> params(
+      GetDevices::Params::Create(*args_));
   if (params->filter && params->filter->max_results)
     max_results = *params->filter->max_results;
 
   api::sessions::Device device_struct;
   device_struct.info = session->session_name;
   device_struct.device_name = session->session_name;
 
   for (sync_driver::SyncedSession::SyncedWindowMap::const_iterator it =
            session->windows.begin();
        it != session->windows.end() &&
        static_cast<int>(device_struct.sessions.size()) < max_results;
        ++it) {
-    scoped_ptr<api::sessions::Session> session_model(CreateSessionModel(
-        *it->second, session->session_tag));
+    std::unique_ptr<api::sessions::Session> session_model(
+        CreateSessionModel(*it->second, session->session_tag));
     if (session_model)
       device_struct.sessions.push_back(std::move(*session_model));
   }
   return device_struct;
 }
 
 bool SessionsGetDevicesFunction::RunSync() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(GetProfile());
   if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
     // Sync not enabled.
     results_ =
         GetDevices::Results::Create(std::vector<api::sessions::Device>());
     return true;
   }
 
   sync_driver::OpenTabsUIDelegate* open_tabs = service->GetOpenTabsUIDelegate();
   std::vector<const sync_driver::SyncedSession*> sessions;
   if (!(open_tabs && open_tabs->GetAllForeignSessions(&sessions))) {
     results_ =
         GetDevices::Results::Create(std::vector<api::sessions::Device>());
     return true;
   }
 
-  scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
+  std::unique_ptr<GetDevices::Params> params(
+      GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   if (params->filter && params->filter->max_results) {
     EXTENSION_FUNCTION_VALIDATE(*params->filter->max_results >= 0 &&
         *params->filter->max_results <= api::sessions::MAX_SESSION_RESULTS);
   }
 
   std::vector<api::sessions::Device> result;
   // Sort sessions from most recent to least recent.
   std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency);
   for (size_t i = 0; i < sessions.size(); ++i)
     result.push_back(CreateDeviceModel(sessions[i]));
 
   results_ = GetDevices::Results::Create(result);
   return true;
 }
 
 void SessionsRestoreFunction::SetInvalidIdError(const std::string& invalid_id) {
   SetError(ErrorUtils::FormatErrorMessage(kInvalidSessionIdError, invalid_id));
 }
 
 
 void SessionsRestoreFunction::SetResultRestoredTab(
     content::WebContents* contents) {
-  scoped_ptr<tabs::Tab> tab(
+  std::unique_ptr<tabs::Tab> tab(
       ExtensionTabUtil::CreateTabObject(contents, extension()));
-  scoped_ptr<api::sessions::Session> restored_session(
+  std::unique_ptr<api::sessions::Session> restored_session(
       CreateSessionModelHelper(base::Time::Now().ToTimeT(), std::move(tab),
-                               scoped_ptr<windows::Window>()));
+                               std::unique_ptr<windows::Window>()));
   results_ = Restore::Results::Create(*restored_session);
 }
 
 bool SessionsRestoreFunction::SetResultRestoredWindow(int window_id) {
   WindowController* controller = NULL;
   if (!windows_util::GetWindowFromWindowID(this, window_id, 0, &controller)) {
     // error_ is set by GetWindowFromWindowId function call.
     return false;
   }
-  scoped_ptr<base::DictionaryValue> window_value(
+  std::unique_ptr<base::DictionaryValue> window_value(
       controller->CreateWindowValueWithTabs(extension()));
-  scoped_ptr<windows::Window> window(windows::Window::FromValue(
-      *window_value));
+  std::unique_ptr<windows::Window> window(
+      windows::Window::FromValue(*window_value));
   results_ = Restore::Results::Create(*CreateSessionModelHelper(
-      base::Time::Now().ToTimeT(), scoped_ptr<tabs::Tab>(), std::move(window)));
+      base::Time::Now().ToTimeT(), std::unique_ptr<tabs::Tab>(),
+      std::move(window)));
   return true;
 }
 
 bool SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
   sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
   sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
 
   if (entries.empty()) {
     SetError(kNoRecentlyClosedSessionsError);
@@ skipping 114 matching lines @@
 
   // Only restore one window at a time.
   std::vector<Browser*> browsers = SessionRestore::RestoreForeignSessionWindows(
       GetProfile(), window, window + 1);
   // Will always create one browser because we only restore one window per call.
   DCHECK_EQ(1u, browsers.size());
   return SetResultRestoredWindow(ExtensionTabUtil::GetWindowId(browsers[0]));
 }
 
 bool SessionsRestoreFunction::RunSync() {
-  scoped_ptr<Restore::Params> params(Restore::Params::Create(*args_));
+  std::unique_ptr<Restore::Params> params(Restore::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   Browser* browser = chrome::FindBrowserWithProfile(GetProfile());
   if (!browser) {
     SetError(kNoBrowserToRestoreSession);
     return false;
   }
 
   if (GetProfile() != GetProfile()->GetOriginalProfile()) {
     SetError(kRestoreInIncognitoError);
     return false;
   }
 
   if (!params->session_id)
     return RestoreMostRecentlyClosed(browser);
 
-  scoped_ptr<SessionId> session_id(SessionId::Parse(*params->session_id));
+  std::unique_ptr<SessionId> session_id(SessionId::Parse(*params->session_id));
   if (!session_id) {
     SetInvalidIdError(*params->session_id);
     return false;
   }
 
   return session_id->IsForeign() ?
       RestoreForeignSession(*session_id, browser)
       : RestoreLocalSession(*session_id, browser);
 }
 
 SessionsEventRouter::SessionsEventRouter(Profile* profile)
     : profile_(profile),
       tab_restore_service_(TabRestoreServiceFactory::GetForProfile(profile)) {
   // TabRestoreServiceFactory::GetForProfile() can return NULL (i.e., when in
   // incognito mode)
   if (tab_restore_service_) {
     tab_restore_service_->LoadTabsFromLastSession();
     tab_restore_service_->AddObserver(this);
   }
 }
 
 SessionsEventRouter::~SessionsEventRouter() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 }
 
 void SessionsEventRouter::TabRestoreServiceChanged(
     sessions::TabRestoreService* service) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  EventRouter::Get(profile_)->BroadcastEvent(make_scoped_ptr(
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
+  EventRouter::Get(profile_)->BroadcastEvent(base::WrapUnique(
       new Event(events::SESSIONS_ON_CHANGED,
                 api::sessions::OnChanged::kEventName, std::move(args))));
 }
 
 void SessionsEventRouter::TabRestoreServiceDestroyed(
     sessions::TabRestoreService* service) {
   tab_restore_service_ = NULL;
 }
 
 SessionsAPI::SessionsAPI(content::BrowserContext* context)
@@ skipping 17 matching lines @@
   return g_factory.Pointer();
 }
 
 void SessionsAPI::OnListenerAdded(const EventListenerInfo& details) {
   sessions_event_router_.reset(
       new SessionsEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions