Switch BaseSessionService to use SequencedWorkerPool instead of FILE thread

chrome/browser/sessions/base_session_service.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/base_session_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
@@ skipping 59 matching lines @@
 
 // static
 const int BaseSessionService::max_persist_navigation_count = 6;
 
 BaseSessionService::BaseSessionService(SessionType type,
                                        Profile* profile,
                                        const base::FilePath& path)
     : profile_(profile),
       weak_factory_(this),
       pending_reset_(false),
-      commands_since_reset_(0) {
+      commands_since_reset_(0),
+      sequence_token_(
+          content::BrowserThread::GetBlockingPool()->GetSequenceToken()) {
   if (profile) {
     // We should never be created when incognito.
     DCHECK(!profile->IsOffTheRecord());
   }
   backend_ = new SessionBackend(type, profile_ ? profile_->GetPath() : path);
   DCHECK(backend_.get());
-
-  // SessionBackend::Init() cannot be scheduled to be called here. There are
-  // service processes which create the BaseSessionService, but they should not
-  // initialize the backend. If they do, the backend will cycle the session
-  // restore files. That in turn prevents the session restore from working when
-  // the normal chromium process is launched. Normally, the backend will be
-  // initialized before it's actually used. However, if we're running as a part
-  // of a test, it must be initialized now.
-  if (!RunningInProduction())
-    backend_->Init();
 }
 
 BaseSessionService::~BaseSessionService() {
 }
 
 void BaseSessionService::DeleteLastSession() {
   RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&SessionBackend::DeleteLastSession, backend()));
 }
@@ skipping 185 matching lines @@
   RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&SessionBackend::ReadLastSessionCommands, backend(),
                  is_canceled, callback_runner));
   return id;
 }
 
 bool BaseSessionService::RunTaskOnBackendThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
-  if (profile_ && BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
-    return BrowserThread::PostTask(BrowserThread::FILE, from_here, task);
+  base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
+  if (!pool->IsShutdownInProgress()) {
+    return pool->PostSequencedWorkerTask(sequence_token_,
+                                         from_here,
+                                         task);
   } else {
-    // Fall back to executing on the main thread if the file thread
-    // has gone away (around shutdown time) or if we're running as
-    // part of a unit test that does not set profile_.
+    // Fall back to executing on the main thread if the sequence
+    // worker pool has been requested to shutdown (around shutdown
+    // time).
     task.Run();

[jochen (gone - plz use gerrit), 2013/08/09 11:49:56]

that means that the tasks will ran in an random order at this point.

isShutdownInProgress() might return true even if there are still running tasks.

Is that intended?

     return true;
   }
 }
-
-bool BaseSessionService::RunningInProduction() const {
-  return profile_ && BrowserThread::IsMessageLoopValid(BrowserThread::FILE);
-}