Remove BrowserThread::UnsafeGetBrowserThread, add UnsafeGetMessageLoopForThread.

chrome/browser/sessions/base_session_service.cc

 // Copyright (c) 2011 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/pickle.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/navigation_entry.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/common/referrer.h"
 #include "webkit/glue/webkit_glue.h"
 
+using content::BrowserThread;
 using WebKit::WebReferrerPolicy;
 
 // InternalGetCommandsRequest -------------------------------------------------
 
 BaseSessionService::InternalGetCommandsRequest::~InternalGetCommandsRequest() {
   STLDeleteElements(&commands);
 }
 
 // BaseSessionService ---------------------------------------------------------
 
@@ skipping 32 matching lines @@
 static const int kSaveDelayMS = 2500;
 
 // static
 const int BaseSessionService::max_persist_navigation_count = 6;
 
 BaseSessionService::BaseSessionService(SessionType type,
                                        Profile* profile,
                                        const FilePath& path)
     : profile_(profile),
       path_(path),
-      backend_thread_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       pending_reset_(false),
       commands_since_reset_(0) {
   if (profile) {
     // We should never be created when incognito.
     DCHECK(!profile->IsOffTheRecord());
   }
   backend_ = new SessionBackend(type,
       profile_ ? profile_->GetPath() : path_);
   DCHECK(backend_.get());
-  backend_thread_ = g_browser_process->file_thread();
-  if (!backend_thread_)
-    backend_->Init();
-  // If backend_thread is non-null, backend will init itself as appropriate.
+
+  RunTaskOnBackendThread(FROM_HERE,
+                         base::Bind(&SessionBackend::Init, backend_));
 }
 
 BaseSessionService::~BaseSessionService() {
 }
 
 void BaseSessionService::DeleteLastSession() {
-  if (!backend_thread()) {
-    backend()->DeleteLastSession();
-  } else {
-    backend_thread()->message_loop()->PostTask(
-        FROM_HERE, base::Bind(&SessionBackend::DeleteLastSession, backend()));
-  }
+  RunTaskOnBackendThread(
+      FROM_HERE,
+      base::Bind(&SessionBackend::DeleteLastSession, backend()));
 }
 
 void BaseSessionService::ScheduleCommand(SessionCommand* command) {
   DCHECK(command);
   commands_since_reset_++;
   pending_commands_.push_back(command);
   StartSaveTimer();
 }
 
 void BaseSessionService::StartSaveTimer() {
   // Don't start a timer when testing (profile == NULL or
   // MessageLoop::current() is NULL).
   if (MessageLoop::current() && profile() && !weak_factory_.HasWeakPtrs()) {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&BaseSessionService::Save, weak_factory_.GetWeakPtr()),
         kSaveDelayMS);
   }
 }
 
 void BaseSessionService::Save() {
   DCHECK(backend());
 
   if (pending_commands_.empty())
     return;
 
-  if (!backend_thread()) {
-    backend()->AppendCommands(
-        new std::vector<SessionCommand*>(pending_commands_), pending_reset_);
-  } else {
-    backend_thread()->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&SessionBackend::AppendCommands, backend(),
-                   new std::vector<SessionCommand*>(pending_commands_),
-                   pending_reset_));
-  }
+  RunTaskOnBackendThread(
+      FROM_HERE,
+      base::Bind(&SessionBackend::AppendCommands, backend(),
+                 new std::vector<SessionCommand*>(pending_commands_),
+                 pending_reset_));
+
   // Backend took ownership of commands.
   pending_commands_.clear();
 
   if (pending_reset_) {
     commands_since_reset_ = 0;
     pending_reset_ = false;
   }
 }
 
 SessionCommand* BaseSessionService::CreateUpdateTabNavigationCommand(
@@ skipping 123 matching lines @@
   // NOTE: Do not track print preview tab because re-opening that page will
   // just display a non-functional print preview page.
   return url.is_valid() && url != GURL(chrome::kChromeUIPrintURL);
 }
 
 BaseSessionService::Handle BaseSessionService::ScheduleGetLastSessionCommands(
     InternalGetCommandsRequest* request,
     CancelableRequestConsumerBase* consumer) {
   scoped_refptr<InternalGetCommandsRequest> request_wrapper(request);
   AddRequest(request, consumer);
-  if (backend_thread()) {
-    backend_thread()->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&SessionBackend::ReadLastSessionCommands, backend(),
-                   request_wrapper));
-  } else {
-    backend()->ReadLastSessionCommands(request);
-  }
+  RunTaskOnBackendThread(
+      FROM_HERE,
+      base::Bind(&SessionBackend::ReadLastSessionCommands, backend(),
+                 request_wrapper));
   return request->handle();
 }
 
 BaseSessionService::Handle
     BaseSessionService::ScheduleGetCurrentSessionCommands(
         InternalGetCommandsRequest* request,
         CancelableRequestConsumerBase* consumer) {
   scoped_refptr<InternalGetCommandsRequest> request_wrapper(request);
   AddRequest(request, consumer);
-  if (backend_thread()) {
-    backend_thread()->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&SessionBackend::ReadCurrentSessionCommands, backend(),
-                   request_wrapper));
-  } else {
-    backend()->ReadCurrentSessionCommands(request);
-  }
+  RunTaskOnBackendThread(
+      FROM_HERE,
+      base::Bind(&SessionBackend::ReadCurrentSessionCommands, backend(),
+                 request_wrapper));
   return request->handle();
 }
+
+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);
+  } 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_.
+    task.Run();
+    return true;
+  }
+}