BookmarkModel cleanup. synced_node is now mobile_node and I'm nuking

chrome/browser/bookmarks/bookmark_html_writer.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/bookmarks/bookmark_html_writer.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 96 matching lines @@
         !static_cast<DictionaryValue*>(bookmarks_.get())->Get(
             BookmarkCodec::kRootsKey, &roots) ||
         roots->GetType() != Value::TYPE_DICTIONARY) {
       NOTREACHED();
       return;
     }
 
     DictionaryValue* roots_d_value = static_cast<DictionaryValue*>(roots);
     Value* root_folder_value;
     Value* other_folder_value;
-    Value* synced_folder_value;
+    Value* mobile_folder_value;
     if (!roots_d_value->Get(BookmarkCodec::kRootFolderNameKey,
                             &root_folder_value) ||
         root_folder_value->GetType() != Value::TYPE_DICTIONARY ||
         !roots_d_value->Get(BookmarkCodec::kOtherBookmarkFolderNameKey,
                             &other_folder_value) ||
         other_folder_value->GetType() != Value::TYPE_DICTIONARY ||
-        !roots_d_value->Get(BookmarkCodec::kSyncedBookmarkFolderNameKey,
-                            &synced_folder_value) ||
-        synced_folder_value->GetType() != Value::TYPE_DICTIONARY) {
+        !roots_d_value->Get(BookmarkCodec::kMobileBookmarkFolderNameKey,
+                            &mobile_folder_value) ||
+        mobile_folder_value->GetType() != Value::TYPE_DICTIONARY) {
       NOTREACHED();
       return;  // Invalid type for root folder and/or other folder.
     }
 
     IncrementIndent();
 
     if (!WriteNode(*static_cast<DictionaryValue*>(root_folder_value),
                    BookmarkNode::BOOKMARK_BAR) ||
         !WriteNode(*static_cast<DictionaryValue*>(other_folder_value),
                    BookmarkNode::OTHER_NODE) ||
-        !WriteNode(*static_cast<DictionaryValue*>(synced_folder_value),
-                   BookmarkNode::SYNCED)) {
+        !WriteNode(*static_cast<DictionaryValue*>(mobile_folder_value),
+                   BookmarkNode::MOBILE)) {
       return;
     }
 
     DecrementIndent();
 
     Write(kFolderChildrenEnd);
     Write(kNewline);
     // File stream close is forced so that unit test could read it.
     file_stream_.Close();
 
@@ skipping 140 matching lines @@
     std::string last_modified_date;
     Value* child_values;
     if (!value.GetString(BookmarkCodec::kDateModifiedKey,
                          &last_modified_date) ||
         !value.Get(BookmarkCodec::kChildrenKey, &child_values) ||
         child_values->GetType() != Value::TYPE_LIST) {
       NOTREACHED();
       return false;
     }
     if (folder_type != BookmarkNode::OTHER_NODE &&
-        folder_type != BookmarkNode::SYNCED) {
-      // The other/synced folder name are not written out. This gives the effect
+        folder_type != BookmarkNode::MOBILE) {
+      // The other/mobile folder name are not written out. This gives the effect
       // of making the contents of the 'other folder' be a sibling to the
       // bookmark bar folder.
       if (!WriteIndent() ||
           !Write(kFolderStart) ||
           !WriteTime(date_added_string) ||
           !Write(kLastModified) ||
           !WriteTime(last_modified_date)) {
         return false;
       }
       if (folder_type == BookmarkNode::BOOKMARK_BAR) {
@@ skipping 22 matching lines @@
           child_value->GetType() != Value::TYPE_DICTIONARY) {
         NOTREACHED();
         return false;
       }
       if (!WriteNode(*static_cast<DictionaryValue*>(child_value),
                      BookmarkNode::FOLDER)) {
         return false;
       }
     }
     if (folder_type != BookmarkNode::OTHER_NODE &&
-        folder_type != BookmarkNode::SYNCED) {
+        folder_type != BookmarkNode::MOBILE) {
       // Close out the folder.
       DecrementIndent();
       if (!WriteIndent() ||
           !Write(kFolderChildrenEnd) ||
           !Write(kNewline)) {
         return false;
       }
     }
     return true;
   }
@@ skipping 35 matching lines @@
                  chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::Source<Profile>(profile_));
 }
 
 BookmarkFaviconFetcher::~BookmarkFaviconFetcher() {
 }
 
 void BookmarkFaviconFetcher::ExportBookmarks() {
   ExtractUrls(profile_->GetBookmarkModel()->bookmark_bar_node());
   ExtractUrls(profile_->GetBookmarkModel()->other_node());
-  ExtractUrls(profile_->GetBookmarkModel()->synced_node());
+  ExtractUrls(profile_->GetBookmarkModel()->mobile_node());
   if (!bookmark_urls_.empty())
     FetchNextFavicon();
   else
     ExecuteWriter();
 }
 
 void BookmarkFaviconFetcher::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 79 matching lines @@
   // BookmarkModel isn't thread safe (nor would we want to lock it down
   // for the duration of the write), as such we make a copy of the
   // BookmarkModel using BookmarkCodec then write from that.
   if (fetcher == NULL) {
     fetcher = new BookmarkFaviconFetcher(profile, path, observer);
     fetcher->ExportBookmarks();
   }
 }
 
 }  // namespace bookmark_html_writer