Passwords: Remove references to BrowserThread from PasswordStore.

chrome/browser/password_manager/password_store.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/password_manager/password_store.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "chrome/browser/password_manager/password_store_consumer.h"
 #include "components/autofill/core/common/password_form.h"
-#include "content/public/browser/browser_thread.h"
 
 using autofill::PasswordForm;
-using content::BrowserThread;
 using std::vector;
 
 namespace {
 
 // Calls |consumer| back with the request result, if |consumer| is still alive.
 // Takes ownership of the elements in |result|, passing ownership to |consumer|
 // if it is still alive.
 void MaybeCallConsumerCallback(base::WeakPtr<PasswordStoreConsumer> consumer,
                                scoped_ptr<vector<PasswordForm*> > result) {
   if (consumer.get())
@@ skipping 30 matching lines @@
   }
 }
 
 void PasswordStore::GetLoginsRequest::ForwardResult() {
   origin_loop_->PostTask(FROM_HERE,
                          base::Bind(&MaybeCallConsumerCallback,
                                     consumer_weak_,
                                     base::Passed(result_.Pass())));
 }
 
-PasswordStore::PasswordStore() {
+PasswordStore::PasswordStore(
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner)
+    : main_task_runner_(main_task_runner), db_thread_runner_(db_thread_runner)

[Garrett Casto, 2014/02/03 15:56:46]

Newline after main_task_runner_ and bring the parens up to the same line as
db_thread_runner_.

[Patrick Dubroy, 2014/02/03 17:43:25]

Done.

+{
 }
 
 bool PasswordStore::Init() {
   ReportMetrics();
   return true;
 }
 
 void PasswordStore::AddLogin(const PasswordForm& form) {
   ScheduleTask(base::Bind(&PasswordStore::WrapModificationTask, this,
       base::Closure(base::Bind(&PasswordStore::AddLoginImpl, this, form))));
@@ skipping 65 matching lines @@
 }
 
 void PasswordStore::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 PasswordStore::~PasswordStore() {}
 
 bool PasswordStore::ScheduleTask(const base::Closure& task) {
   scoped_refptr<base::SequencedTaskRunner> task_runner(
-      GetTaskRunner());
+      GetBackgroundTaskRunner());
   if (task_runner.get())
     return task_runner->PostTask(FROM_HERE, task);
   return false;
 }
 
-scoped_refptr<base::SequencedTaskRunner> PasswordStore::GetTaskRunner() {
-  return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB);
+scoped_refptr<base::SequencedTaskRunner>
+PasswordStore::GetBackgroundTaskRunner() {
+  return db_thread_runner_;
 }
 
 void PasswordStore::ForwardLoginsResult(GetLoginsRequest* request) {
   request->ApplyIgnoreLoginsCutoff();
   request->ForwardResult();
 }
 
 void PasswordStore::CopyAndForwardLoginsResult(
     PasswordStore::GetLoginsRequest* request,
     const vector<PasswordForm*>& matched_forms) {
   // Copy the contents of |matched_forms| into the request. The request takes
   // ownership of the PasswordForm elements.
   *(request->result()) = matched_forms;
   ForwardLoginsResult(request);
 }
 
 void PasswordStore::LogStatsForBulkDeletion(int num_deletions) {
   UMA_HISTOGRAM_COUNTS("PasswordManager.NumPasswordsDeletedByBulkDelete",
                        num_deletions);
 }
 
 template<typename BackendFunc>
 void PasswordStore::Schedule(
     BackendFunc func,
     PasswordStoreConsumer* consumer) {
   GetLoginsRequest* request = new GetLoginsRequest(consumer);
   consumer->cancelable_task_tracker()->PostTask(
-      GetTaskRunner(),
+      GetBackgroundTaskRunner(),
       FROM_HERE,
       base::Bind(func, this, base::Owned(request)));
 }
 
 void PasswordStore::WrapModificationTask(base::Closure task) {
-#if !defined(OS_MACOSX)
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-#endif  // !defined(OS_MACOSX)
+  DCHECK(!main_task_runner_->BelongsToCurrentThread());
   task.Run();
   PostNotifyLoginsChanged();
 }
 
 void PasswordStore::PostNotifyLoginsChanged() {
-#if !defined(OS_MACOSX)
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-#endif  // !defined(OS_MACOSX)
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
+  DCHECK(!main_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
+      FROM_HERE,
       base::Bind(&PasswordStore::NotifyLoginsChanged, this));
 }
 
 void PasswordStore::NotifyLoginsChanged() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   FOR_EACH_OBSERVER(Observer, observers_, OnLoginsChanged());
 }