Renames BoomarkBarModel to BookmarkModel.

chrome/browser/importer.cc

 // Copyright (c) 2006-2008 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/importer.h"
 
 #include <map>
 
 #include "base/file_util.h"
 #include "base/gfx/image_operations.h"
 #include "base/gfx/png_encoder.h"
 #include "base/string_util.h"
-#include "chrome/browser/bookmarks/bookmark_bar_model.h"
+#include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/firefox2_importer.h"
 #include "chrome/browser/firefox3_importer.h"
 #include "chrome/browser/firefox_importer_utils.h"
 #include "chrome/browser/firefox_profile_lock.h"
 #include "chrome/browser/ie_importer.h"
 #include "chrome/browser/template_url_model.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/gfx/favicon_size.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/views/window.h"
 #include "webkit/glue/image_decoder.h"
 
 #include "generated_resources.h"
 
 // ProfileWriter.
 
-bool ProfileWriter::BookmarkBarModelIsLoaded() const {
-  return profile_->GetBookmarkBarModel()->IsLoaded();
+bool ProfileWriter::BookmarkModelIsLoaded() const {
+  return profile_->GetBookmarkModel()->IsLoaded();
 }
 
-void ProfileWriter::AddBookmarkBarModelObserver(
-    BookmarkBarModelObserver* observer) {
-  profile_->GetBookmarkBarModel()->AddObserver(observer);
+void ProfileWriter::AddBookmarkModelObserver(BookmarkModelObserver* observer) {
+  profile_->GetBookmarkModel()->AddObserver(observer);
 }
 
 bool ProfileWriter::TemplateURLModelIsLoaded() const {
   return profile_->GetTemplateURLModel()->loaded();
 }
 
 void ProfileWriter::AddTemplateURLModelObserver(
     NotificationObserver* observer) {
   TemplateURLModel* model = profile_->GetTemplateURLModel();
   NotificationService::current()->AddObserver(
@@ skipping 19 matching lines @@
   DCHECK(profile_);
 
   PrefService* prefs = profile_->GetPrefs();
   // NOTE: We set the kHomePage value, but keep the NewTab page as the homepage.
   prefs->SetString(prefs::kHomePage, ASCIIToWide(home_page.spec()));
   prefs->ScheduleSavePersistentPrefs(g_browser_process->file_thread());
 }
 
 void ProfileWriter::AddBookmarkEntry(
     const std::vector<BookmarkEntry>& bookmark) {
-  BookmarkBarModel* model = profile_->GetBookmarkBarModel();
+  BookmarkModel* model = profile_->GetBookmarkModel();
   DCHECK(model->IsLoaded());
 
   bool show_bookmark_toolbar = false;
-  std::set<BookmarkBarNode*> groups_added_to;
+  std::set<BookmarkNode*> groups_added_to;
   for (std::vector<BookmarkEntry>::const_iterator it = bookmark.begin();
        it != bookmark.end(); ++it) {
     // Don't insert this url if it exists in model or url is not valid.
     if (model->GetNodeByURL(it->url) != NULL || !it->url.is_valid())
       continue;
 
-    // Set up groups in BookmarkBarModel in such a way that path[i] is
+    // Set up groups in BookmarkModel in such a way that path[i] is
     // the subgroup of path[i-1]. Finally they construct a path in the
     // model:
     //   path[0] \ path[1] \ ... \ path[size() - 1]
-    BookmarkBarNode* parent =
+    BookmarkNode* parent =
         (it->in_toolbar ? model->GetBookmarkBarNode() : model->other_node());
     for (std::vector<std::wstring>::const_iterator i = it->path.begin();
          i != it->path.end(); ++i) {
-      BookmarkBarNode* child = NULL;
+      BookmarkNode* child = NULL;
       for (int index = 0; index < parent->GetChildCount(); ++index) {
-        BookmarkBarNode* node = parent->GetChild(index);
+        BookmarkNode* node = parent->GetChild(index);
         if ((node->GetType() == history::StarredEntry::BOOKMARK_BAR ||
              node->GetType() == history::StarredEntry::USER_GROUP) &&
             node->GetTitle() == *i) {
           child = node;
           break;
         }
       }
       if (child == NULL)
         child = model->AddGroup(parent, parent->GetChildCount(), *i);
       parent = child;
     }
     groups_added_to.insert(parent);
     model->AddURLWithCreationTime(parent, parent->GetChildCount(),
         it->title, it->url, it->creation_time);
 
     // If some items are put into toolbar, it looks like the user was using
     // it in their last browser. We turn on the bookmarks toolbar.
     if (it->in_toolbar)
       show_bookmark_toolbar = true;
   }
 
   // Reset the date modified time of the groups we added to. We do this to
   // make sure the 'recently added to' combobox in the bubble doesn't get random
   // groups.
-  for (std::set<BookmarkBarNode*>::const_iterator i = groups_added_to.begin();
+  for (std::set<BookmarkNode*>::const_iterator i = groups_added_to.begin();
        i != groups_added_to.end(); ++i) {
     model->ResetDateGroupModified(*i);
   }
 
   if (show_bookmark_toolbar)
     ShowBookmarkBar();
 }
 
 void ProfileWriter::AddFavicons(
     const std::vector<history::ImportedFavIconUsage>& favicons) {
@@ skipping 156 matching lines @@
       waiting_for_bookmarkbar_model_(false),
       waiting_for_template_url_model_(false),
       is_source_readable_(true) {
   DetectSourceProfiles();
 }
 
 ImporterHost::~ImporterHost() {
   STLDeleteContainerPointers(source_profiles_.begin(), source_profiles_.end());
 }
 
-void ImporterHost::Loaded(BookmarkBarModel* model) {
+void ImporterHost::Loaded(BookmarkModel* model) {
   model->RemoveObserver(this);
   waiting_for_bookmarkbar_model_ = false;
   InvokeTaskIfDone();
 }
 
 void ImporterHost::Observe(NotificationType type,
                            const NotificationSource& source,
                            const NotificationDetails& details) {
   DCHECK(type == TEMPLATE_URL_MODEL_LOADED);
   TemplateURLModel* model = Source<TemplateURLModel>(source).ptr();
@@ skipping 49 matching lines @@
       profile_info.browser_type == FIREFOX3) {
     firefox_lock_.reset(new FirefoxProfileLock(profile_info.source_path));
     if (!firefox_lock_->HasAcquired()) {
       // If fail to acquire the lock, we set the source unreadable and
       // show a warning dialog.
       is_source_readable_ = false;
       ShowWarningDialog();
     }
   }
 
-  // BookmarkBarModel should be loaded before adding IE favorites. So we
-  // observe the BookmarkBarModel if needed, and start the task after
-  // it has been loaded.
-  if ((items & FAVORITES) && !writer_->BookmarkBarModelIsLoaded()) {
-    writer_->AddBookmarkBarModelObserver(this);
+  // BookmarkModel should be loaded before adding IE favorites. So we observe
+  // the BookmarkModel if needed, and start the task after it has been loaded.
+  if ((items & FAVORITES) && !writer_->BookmarkModelIsLoaded()) {
+    writer_->AddBookmarkModelObserver(this);
     waiting_for_bookmarkbar_model_ = true;
   }
 
   // Observes the TemplateURLModel if needed to import search engines from the
   // other browser. We also check to see if we're importing bookmarks because
   // we can import bookmark keywords from Firefox as search engines.
   if ((items & SEARCH_ENGINES) || (items & FAVORITES)) {
     if (!writer_->TemplateURLModelIsLoaded()) {
       writer_->AddTemplateURLModelObserver(this);
       waiting_for_template_url_model_ = true;
@@ skipping 146 matching lines @@
   if (!source_path.empty()) {
     ProfileInfo* firefox = new ProfileInfo();
     firefox->description = l10n_util::GetString(IDS_IMPORT_FROM_FIREFOX);
     firefox->browser_type = firefox_type;
     firefox->source_path = source_path;
     firefox->app_path = GetFirefoxInstallPath();
     source_profiles_.push_back(firefox);
   }
 }