Convert SessionService to use new CancelableTaskTracker

chrome/browser/sessions/session_restore.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/sessions/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/performance_monitor/startup_timer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabrestore.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
+#include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/session_storage_namespace.h"
@@ skipping 470 matching lines @@
     // Chrome doesn't prematurely exit AddRef the process. We'll release in the
     // destructor when restore is done.
     g_browser_process->AddRefModule();
   }
 
   Browser* Restore() {
     SessionService* session_service =
         SessionServiceFactory::GetForProfile(profile_);
     DCHECK(session_service);
     session_service->GetLastSession(
-        &request_consumer_,
-        base::Bind(&SessionRestoreImpl::OnGotSession, base::Unretained(this)));
+        base::Bind(&SessionRestoreImpl::OnGotSession, base::Unretained(this)),
+        &cancelable_task_tracker_);
 
     if (synchronous_) {
       {
         MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
         MessageLoop::current()->Run();
       }
       Browser* browser = ProcessSessionWindows(&windows_, active_window_id_);
       delete this;
       return browser;
     }
@@ skipping 166 matching lines @@
       MessageLoop::current()->DeleteSoon(FROM_HERE, this);
     }
 
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-End", false);
 #endif
     return browser;
   }
 
-  void OnGotSession(SessionService::Handle handle,
-                    std::vector<SessionWindow*>* windows,
+  void OnGotSession(ScopedVector<SessionWindow> windows,

[marja, 2012/12/06 08:21:58]

Is it possible to avoid copying the ScopedVector when passing the param?

[kaiwang, 2012/12/06 18:07:52]

no.. ScopedVector is a non-copyable type like scoped_ptr. So the only way to put
it in Callback is declare like this. I think this is a good thing, the callback
writer knows clearly all the SessionWindows are owned here.

The only member of ScopedVector is an std::vector, and Pass() uses
vector::swap(). So the construction is very cheap.

[kaiwang, 2012/12/06 18:29:31]

Oh, I think I was wrong. It's possible to Bind a 
"const ScopedVector<...>&"
Although I don't feel this makes much sense...

But the case of this CL, SessionCallbacks can own SessionWindows (see old
comment in session_service.h), so the ScopedVector must be modifiable.

[marja, 2012/12/10 18:22:56]

Hmm, so this copy probably gets ScopedVector(RValue other)
called, and it does the swap, so the original ScopedVector is emptied, and
nothing disastrous happens. Ok.

                     SessionID::id_type active_window_id) {
     base::TimeDelta time_to_got_sessions =
         base::TimeTicks::Now() - restore_started_;
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "SessionRestore.TimeToGotSessions",
         time_to_got_sessions,
         base::TimeDelta::FromMilliseconds(10),
         base::TimeDelta::FromSeconds(1000),
         100);
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-GotSession", false);
 #endif
     if (synchronous_) {
       // See comment above windows_ as to why we don't process immediately.
-      windows_.swap(*windows);
+      windows_.swap(windows.get());
       active_window_id_ = active_window_id;
       MessageLoop::current()->QuitNow();
       return;
     }
 
-    ProcessSessionWindows(windows, active_window_id);
+    ProcessSessionWindows(&windows.get(), active_window_id);
   }
 
   Browser* ProcessSessionWindows(std::vector<SessionWindow*>* windows,
                                  SessionID::id_type active_window_id) {
     VLOG(1) << "ProcessSessionWindows " << windows->size();
     base::TimeDelta time_to_process_sessions =
         base::TimeTicks::Now() - restore_started_;
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "SessionRestore.TimeToProcessSessions",
         time_to_process_sessions,
@@ skipping 348 matching lines @@
 
   // If true and there is an error or there are no windows to restore, we
   // create a tabbed browser anyway. This is used on startup to make sure at
   // at least one window is created.
   const bool always_create_tabbed_browser_;
 
   // Set of URLs to open in addition to those restored from the session.
   std::vector<GURL> urls_to_open_;
 
   // Used to get the session.
-  CancelableRequestConsumer request_consumer_;
+  CancelableTaskTracker cancelable_task_tracker_;
 
   // Responsible for loading the tabs.
   scoped_refptr<TabLoader> tab_loader_;
 
   // When synchronous we run a nested message loop. To avoid creating windows
   // from the nested message loop (which can make exiting the nested message
   // loop take a while) we cache the SessionWindows here and create the actual
   // windows when the nested message loop exits.
   std::vector<SessionWindow*> windows_;
   SessionID::id_type active_window_id_;
@@ skipping 68 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }