[Sync] Remove --create-mobile-bookmarks-folder

chrome/browser/sync/glue/bookmark_model_associator.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.
 

[Nicolas Zea, 2012/02/27 20:03:12]

remove extra newline

[akalin, 2012/02/27 22:04:18]

Done.

+
 #include "chrome/browser/sync/glue/bookmark_model_associator.h"
 
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/read_transaction.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/util/cryptographer.h"
-#include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace browser_sync {
 
 // The sync protocol identifies top-level entities by means of well-known tags,
 // which should not be confused with titles.  Each tag corresponds to a
 // singleton instance of a particular top-level node in a user's share; the
 // tags are consistent across users. The tags allow us to locate the specific
@@ skipping 145 matching lines @@
 }
 
 const BookmarkNode* BookmarkNodeIdIndex::Find(int64 id) const {
   BookmarkIdMap::const_iterator iter = node_index_.find(id);
   return iter == node_index_.end() ? NULL : iter->second;
 }
 
 BookmarkModelAssociator::BookmarkModelAssociator(
     BookmarkModel* bookmark_model,
     sync_api::UserShare* user_share,
-    DataTypeErrorHandler* unrecoverable_error_handler)
+    DataTypeErrorHandler* unrecoverable_error_handler,
+    bool create_mobile_bookmarks_folder)
     : bookmark_model_(bookmark_model),
       user_share_(user_share),
       unrecoverable_error_handler_(unrecoverable_error_handler),
+      create_mobile_bookmarks_folder_(create_mobile_bookmarks_folder),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       number_of_new_sync_nodes_created_at_association_(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_);
   DCHECK(user_share_);
   DCHECK(unrecoverable_error_handler_);
 }
 
 BookmarkModelAssociator::~BookmarkModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 188 matching lines @@
     error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
   if (!AssociateTaggedPermanentNode(bookmark_model_->bookmark_bar_node(),
                                     kBookmarkBarTag)) {
     error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
   if (!AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
                                     kMobileBookmarksTag) &&
-      // The mobile folder only need exist if kCreateMobileBookmarksFolder is
-      // set.
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kCreateMobileBookmarksFolder)) {
+      create_mobile_bookmarks_folder_) {
     error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
+
   int64 bookmark_bar_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->bookmark_bar_node()->id());
   DCHECK_NE(bookmark_bar_sync_id, sync_api::kInvalidId);
   int64 other_bookmarks_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->other_node()->id());
   DCHECK_NE(other_bookmarks_sync_id, sync_api::kInvalidId);
   int64 mobile_bookmarks_sync_id = GetSyncIdFromChromeId(
        bookmark_model_->mobile_node()->id());
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kCreateMobileBookmarksFolder)) {
+  if (create_mobile_bookmarks_folder_) {
     DCHECK_NE(sync_api::kInvalidId, mobile_bookmarks_sync_id);
   }
 
   std::stack<int64> dfs_stack;
   if (mobile_bookmarks_sync_id != sync_api::kInvalidId)
     dfs_stack.push(mobile_bookmarks_sync_id);
   dfs_stack.push(other_bookmarks_sync_id);
   dfs_stack.push(bookmark_bar_sync_id);
 
   sync_api::WriteTransaction trans(FROM_HERE, user_share_);
@@ skipping 135 matching lines @@
     // We should always be able to find the permanent nodes.
     return false;
   }
   int64 other_bookmarks_id;
   if (!GetSyncIdForTaggedNode(kOtherBookmarksTag, &other_bookmarks_id)) {
     // We should always be able to find the permanent nodes.
     return false;
   }
   int64 mobile_bookmarks_id = -1;
   if (!GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_id) &&
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kCreateMobileBookmarksFolder)) {
+      create_mobile_bookmarks_folder_) {
     return false;
   }
 
   // Build a bookmark node ID index since we are going to repeatedly search for
   // bookmark nodes by their IDs.
   BookmarkNodeIdIndex id_index;
   id_index.AddAll(bookmark_model_->bookmark_bar_node());
   id_index.AddAll(bookmark_model_->other_node());
   id_index.AddAll(bookmark_model_->mobile_node());
 
@@ skipping 59 matching lines @@
 bool BookmarkModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, user_share_);
   const syncable::ModelTypeSet encrypted_types =
       sync_api::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(syncable::BOOKMARKS) ||
       trans.GetCryptographer()->is_ready();
 }
 
 }  // namespace browser_sync