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

chrome/browser/ui/webui/foreign_session_handler.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/ui/webui/foreign_session_handler.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 26 matching lines @@
 #include "ui/base/webui/web_ui_util.h"
 
 namespace browser_sync {
 
 namespace {
 
 // Maximum number of sessions we're going to display on the NTP
 const size_t kMaxSessionsToShow = 10;
 
 // Helper method to create JSON compatible objects from Session objects.
-scoped_ptr<base::DictionaryValue> SessionTabToValue(
+std::unique_ptr<base::DictionaryValue> SessionTabToValue(
     const ::sessions::SessionTab& tab) {
   if (tab.navigations.empty())
     return nullptr;
 
   int selected_index = std::min(tab.current_navigation_index,
                                 static_cast<int>(tab.navigations.size() - 1));
   const ::sessions::SerializedNavigationEntry& current_navigation =
       tab.navigations.at(selected_index);
   GURL tab_url = current_navigation.virtual_url();
   if (!tab_url.is_valid() ||
       tab_url.spec() == chrome::kChromeUINewTabURL) {
     return nullptr;
   }
 
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
   NewTabUI::SetUrlTitleAndDirection(dictionary.get(),
                                     current_navigation.title(), tab_url);
   dictionary->SetString("type", "tab");
   dictionary->SetDouble("timestamp",
                         static_cast<double>(tab.timestamp.ToInternalValue()));
   // TODO(jeremycho): This should probably be renamed to tabId to avoid
   // confusion with the ID corresponding to a session.  Investigate all the
   // places (C++ and JS) where this is being used.  (http://crbug.com/154865).
   dictionary->SetInteger("sessionId", tab.tab_id.id());
   return dictionary;
 }
 
 // Helper for initializing a boilerplate SessionWindow JSON compatible object.
-scoped_ptr<base::DictionaryValue> BuildWindowData(
+std::unique_ptr<base::DictionaryValue> BuildWindowData(
     base::Time modification_time,
     SessionID::id_type window_id) {
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
   // The items which are to be written into |dictionary| are also described in
   // chrome/browser/resources/ntp4/other_sessions.js in @typedef for WindowData.
   // Please update it whenever you add or remove any keys here.
   dictionary->SetString("type", "window");
   dictionary->SetDouble("timestamp", modification_time.ToInternalValue());
   const base::TimeDelta last_synced = base::Time::Now() - modification_time;
   // If clock skew leads to a future time, or we last synced less than a minute
   // ago, output "Just now".
   dictionary->SetString(
       "userVisibleTimestamp",
       last_synced < base::TimeDelta::FromMinutes(1)
           ? l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW)
           : ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_ELAPSED,
                                    ui::TimeFormat::LENGTH_SHORT, last_synced));
 
   dictionary->SetInteger("sessionId", window_id);
   return dictionary;
 }
 
 // Helper method to create JSON compatible objects from SessionWindow objects.
-scoped_ptr<base::DictionaryValue> SessionWindowToValue(
+std::unique_ptr<base::DictionaryValue> SessionWindowToValue(
     const ::sessions::SessionWindow& window) {
   if (window.tabs.empty())
     return nullptr;
-  scoped_ptr<base::ListValue> tab_values(new base::ListValue());
+  std::unique_ptr<base::ListValue> tab_values(new base::ListValue());
   // Calculate the last |modification_time| for all entries within a window.
   base::Time modification_time = window.timestamp;
   for (const ::sessions::SessionTab* tab : window.tabs) {
-    scoped_ptr<base::DictionaryValue> tab_value(SessionTabToValue(*tab));
+    std::unique_ptr<base::DictionaryValue> tab_value(SessionTabToValue(*tab));
     if (tab_value.get()) {
       modification_time = std::max(modification_time,
                                    tab->timestamp);
       tab_values->Append(tab_value.release());
     }
   }
   if (tab_values->GetSize() == 0)
     return nullptr;
-  scoped_ptr<base::DictionaryValue> dictionary(
-    BuildWindowData(window.timestamp, window.window_id.id()));
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      BuildWindowData(window.timestamp, window.window_id.id()));
   dictionary->Set("tabs", tab_values.release());
   return dictionary;
 }
 
 }  // namespace
 
 ForeignSessionHandler::ForeignSessionHandler() : scoped_observer_(this) {
   load_attempt_time_ = base::TimeTicks::Now();
 }
 
@@ skipping 132 matching lines @@
                           base::TimeTicks::Now() - load_attempt_time_);
       load_attempt_time_ = base::TimeTicks();
     }
 
     // Use a pref to keep track of sessions that were collapsed by the user.
     // To prevent the pref from accumulating stale sessions, clear it each time
     // and only add back sessions that are still current.
     DictionaryPrefUpdate pref_update(Profile::FromWebUI(web_ui())->GetPrefs(),
                                      prefs::kNtpCollapsedForeignSessions);
     base::DictionaryValue* current_collapsed_sessions = pref_update.Get();
-    scoped_ptr<base::DictionaryValue> collapsed_sessions(
+    std::unique_ptr<base::DictionaryValue> collapsed_sessions(
         current_collapsed_sessions->DeepCopy());
     current_collapsed_sessions->Clear();
 
     // Note: we don't own the SyncedSessions themselves.
     for (size_t i = 0; i < sessions.size() && i < kMaxSessionsToShow; ++i) {
       const sync_driver::SyncedSession* session = sessions[i];
       const std::string& session_tag = session->session_tag;
-      scoped_ptr<base::DictionaryValue> session_data(
+      std::unique_ptr<base::DictionaryValue> session_data(
           new base::DictionaryValue());
       // The items which are to be written into |session_data| are also
       // described in chrome/browser/resources/ntp4/other_sessions.js in
       // @typedef for SessionData. Please update it whenever you add or remove
       // any keys here.
       session_data->SetString("tag", session_tag);
       session_data->SetString("name", session->session_name);
       session_data->SetString("deviceType", session->DeviceTypeAsString());
       session_data->SetString("modifiedTime",
                               FormatSessionTime(session->modified_time));
 
       bool is_collapsed = collapsed_sessions->HasKey(session_tag);
       session_data->SetBoolean("collapsed", is_collapsed);
       if (is_collapsed)
         current_collapsed_sessions->SetBoolean(session_tag, true);
 
-      scoped_ptr<base::ListValue> window_list(new base::ListValue());
+      std::unique_ptr<base::ListValue> window_list(new base::ListValue());
       const std::string group_name =
           base::FieldTrialList::FindFullName("TabSyncByRecency");
       if (group_name != "Enabled") {
         // Order tabs by visual order within window.
         for (auto map_iter : session->windows) {
-          scoped_ptr<base::DictionaryValue> window_data(
+          std::unique_ptr<base::DictionaryValue> window_data(
               SessionWindowToValue(*map_iter.second));
           if (window_data.get())
             window_list->Append(window_data.release());
         }
       } else {
         // Order tabs by recency. This involves creating a synthetic singleton
         // window that contains all the tabs of the session.
         base::Time modification_time;
         std::vector<const ::sessions::SessionTab*> tabs;
         open_tabs->GetForeignSessionTabs(session_tag, &tabs);
-        scoped_ptr<base::ListValue> tab_values(new base::ListValue());
+        std::unique_ptr<base::ListValue> tab_values(new base::ListValue());
         for (const ::sessions::SessionTab* tab : tabs) {
-          scoped_ptr<base::DictionaryValue> tab_value(SessionTabToValue(*tab));
+          std::unique_ptr<base::DictionaryValue> tab_value(
+              SessionTabToValue(*tab));
           if (tab_value.get()) {
             modification_time = std::max(modification_time, tab->timestamp);
             tab_values->Append(tab_value.release());
           }
         }
         if (tab_values->GetSize() != 0) {
-          scoped_ptr<base::DictionaryValue> window_data(
+          std::unique_ptr<base::DictionaryValue> window_data(
               BuildWindowData(modification_time, 1));
           window_data->Set("tabs", tab_values.release());
           window_list->Append(window_data.release());
         }
       }
 
       session_data->Set("windows", window_list.release());
       session_list.Append(session_data.release());
     }
   }
@@ skipping 93 matching lines @@
   // collapsed state persists.
   PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
   DictionaryPrefUpdate update(prefs, prefs::kNtpCollapsedForeignSessions);
   if (is_collapsed)
     update.Get()->SetBoolean(session_tag, true);
   else
     update.Get()->Remove(session_tag, NULL);
 }
 
 }  // namespace browser_sync