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
@@ skipping 201 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);
+  if (RunningInProduction()) {
+    return content::BrowserThread::GetBlockingPool()->
+        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) or if we're running as part of a unit test that does not
+    // set profile_.
     task.Run();
     return true;
   }
 }
 
 bool BaseSessionService::RunningInProduction() const {
-  return profile_ && BrowserThread::IsMessageLoopValid(BrowserThread::FILE);
+  base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
+  return profile_ && !pool->IsShutdownInProgress();

[marja, 2013/08/08 20:16:43]

Why checking IsShutdownInProgress here? Will that somehow be true in tests (like
the function name would hint), or.. is the function name not reflecting what it
does? Will there be "pool" in tests? Do we need the separation between tests and
production code any more?

[oshima, 2013/08/08 20:36:53]

This is just replacement of
BrowserThread::IsMessageLoopValid(BrowserThread::FILE) in original code.
This is to run tasks in UI thread during shutdown, otherwise tasks may not
be processed. I believe test case is handled by | profile_ |


I do agree that method name is a bit misleading though.
I'm happy to rename it to something like TaskShouldRunOnMainThread/UIThread or
something you like. Please let me know.

 }