Removing instances of profile_->GetBookmarkModel() as part of converting BookmarkModel to a PKS.

chrome/browser/automation/testing_automation_provider.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/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 21 matching lines @@
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/automation/automation_browser_tracker.h"
 #include "chrome/browser/automation/automation_provider_json.h"
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/automation/automation_provider_observers.h"
 #include "chrome/browser/automation/automation_tab_tracker.h"
 #include "chrome/browser/automation/automation_util.h"
 #include "chrome/browser/automation/automation_window_tracker.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_storage.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
@@ skipping 1303 matching lines @@
 }
 
 void TestingAutomationProvider::GetBookmarksAsJSON(
     int handle,
     std::string* bookmarks_as_json,
     bool* success) {
   *success = false;
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      if (!browser->profile()->GetBookmarkModel()->IsLoaded()) {
+      BookmarkModel* bookmark_model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
+      if (!bookmark_model->IsLoaded()) {
         return;
       }
       scoped_refptr<BookmarkStorage> storage(new BookmarkStorage(
-          browser->profile(),
-          browser->profile()->GetBookmarkModel()));
+          browser->profile(), bookmark_model));
       *success = storage->SerializeData(bookmarks_as_json);
     }
   }
 }
 
 void TestingAutomationProvider::WaitForBookmarkModelToLoad(
     int handle,
     IPC::Message* reply_message) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
-    BookmarkModel* model = browser->profile()->GetBookmarkModel();
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForProfile(browser->profile());
     if (model->IsLoaded()) {
       AutomationMsg_WaitForBookmarkModelToLoad::WriteReplyParams(
           reply_message, true);
       Send(reply_message);
     } else {
       // The observer will delete itself when done.
       new AutomationProviderBookmarkModelObserver(this, reply_message,
                                                   model);
     }
   }
 }
 
 void TestingAutomationProvider::AddBookmarkGroup(int handle,
                                                  int64 parent_id,
                                                  int index,
                                                  std::wstring title,
                                                  bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      BookmarkModel* model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* parent = model->GetNodeByID(parent_id);
       DCHECK(parent);
       if (parent) {
         const BookmarkNode* child = model->AddFolder(parent, index,
                                                      WideToUTF16Hack(title));
         DCHECK(child);
         if (child)
           *success = true;
       }
     }
   }
   *success = false;
 }
 
 void TestingAutomationProvider::AddBookmarkURL(int handle,
                                                int64 parent_id,
                                                int index,
                                                std::wstring title,
                                                const GURL& url,
                                                bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      BookmarkModel* model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* parent = model->GetNodeByID(parent_id);
       DCHECK(parent);
       if (parent) {
         const BookmarkNode* child = model->AddURL(parent, index,
                                                   WideToUTF16Hack(title), url);
         DCHECK(child);
         if (child)
           *success = true;
       }
     }
   }
   *success = false;
 }
 
 void TestingAutomationProvider::ReparentBookmark(int handle,
                                                  int64 id,
                                                  int64 new_parent_id,
                                                  int index,
                                                  bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      BookmarkModel* model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* node = model->GetNodeByID(id);
       DCHECK(node);
       const BookmarkNode* new_parent = model->GetNodeByID(new_parent_id);
       DCHECK(new_parent);
       if (node && new_parent) {
         model->Move(node, new_parent, index);
         *success = true;
       }
     }
   }
   *success = false;
 }
 
 void TestingAutomationProvider::SetBookmarkTitle(int handle,
                                                  int64 id,
                                                  std::wstring title,
                                                  bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      BookmarkModel* model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* node = model->GetNodeByID(id);
       DCHECK(node);
       if (node) {
         model->SetTitle(node, WideToUTF16Hack(title));
         *success = true;
       }
     }
   }
   *success = false;
 }
 
 void TestingAutomationProvider::SetBookmarkURL(int handle,
                                                int64 id,
                                                const GURL& url,
                                                bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      BookmarkModel* model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* node = model->GetNodeByID(id);
       DCHECK(node);
       if (node) {
         model->SetURL(node, url);
         *success = true;
       }
     }
   }
   *success = false;
 }
 
 void TestingAutomationProvider::RemoveBookmark(int handle,
                                                int64 id,
                                                bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
-      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      BookmarkModel* model =
+          BookmarkModelFactory::GetForProfile(browser->profile());
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* node = model->GetNodeByID(id);
       DCHECK(node);
       if (node) {
         const BookmarkNode* parent = node->parent();
         DCHECK(parent);
         model->Remove(parent, parent->GetIndexOf(node));
@@ skipping 5546 matching lines @@
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   if (chrome::GetActiveWebContents(browser) != tab)
     chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, tab), true);
 }