Skip managed bookmarks at the BookmarkChangeProcessor.

chrome/browser/sync/glue/bookmark_change_processor.cc

 // Copyright 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/sync/glue/bookmark_change_processor.h"
 
 #include <map>
 #include <stack>
 #include <vector>
 
 #include "base/location.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/undo/bookmark_undo_service.h"
 #include "chrome/browser/undo/bookmark_undo_service_factory.h"
 #include "chrome/browser/undo/bookmark_undo_utils.h"
+#include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/internal_api/public/change_record.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/syncable/entry.h"  // TODO(tim): Investigating bug 121587.
 #include "sync/syncable/syncable_write_transaction.h"
 #include "ui/gfx/favicon_size.h"
@@ skipping 171 matching lines @@
     } else {
       int64 child_id = node.GetFirstChildId();
       if (child_id != syncer::kInvalidId) {
         dfs_sync_id_stack.push(child_id);
       }
     }
   }
 }
 
 void BookmarkChangeProcessor::CreateOrUpdateSyncNode(const BookmarkNode* node) {
+  if (!CanSyncNode(node)) {
+    NOTREACHED();
+    return;
+  }
+
   const BookmarkNode* parent = node->parent();
   int index = node->parent()->GetIndexOf(node);
 
   int64 new_version = syncer::syncable::kInvalidTransactionVersion;
   int64 sync_id = syncer::kInvalidId;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
     sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
     if (sync_id != syncer::kInvalidId) {
@@ skipping 28 matching lines @@
 
 void BookmarkChangeProcessor::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
   bookmark_model_ = NULL;
 }
 
 void BookmarkChangeProcessor::BookmarkNodeAdded(BookmarkModel* model,
                                                 const BookmarkNode* parent,
                                                 int index) {
   DCHECK(share_handle());
-  CreateOrUpdateSyncNode(parent->GetChild(index));
+  const BookmarkNode* node = parent->GetChild(index);
+  if (CanSyncNode(node))
+    CreateOrUpdateSyncNode(node);
 }
 
 // static
 int64 BookmarkChangeProcessor::CreateSyncNode(const BookmarkNode* parent,
     BookmarkModel* model, int index, syncer::WriteTransaction* trans,
     BookmarkModelAssociator* associator,
     sync_driver::DataTypeErrorHandler* error_handler) {
   const BookmarkNode* child = parent->GetChild(index);
   DCHECK(child);
 
@@ skipping 18 matching lines @@
 
   return sync_child.GetId();
 }
 
 void BookmarkChangeProcessor::BookmarkNodeRemoved(
     BookmarkModel* model,
     const BookmarkNode* parent,
     int index,
     const BookmarkNode* node,
     const std::set<GURL>& removed_urls) {
-  RemoveSyncNodeHierarchy(node);
+  if (CanSyncNode(node))
+    RemoveSyncNodeHierarchy(node);
 }
 
 void BookmarkChangeProcessor::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   RemoveAllSyncNodes();
 }
 
 void BookmarkChangeProcessor::BookmarkNodeChanged(BookmarkModel* model,
                                                   const BookmarkNode* node) {
+  if (!CanSyncNode(node))
+    return;
   // We shouldn't see changes to the top-level nodes.
   if (model->is_permanent_node(node)) {
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
   CreateOrUpdateSyncNode(node);
 }
 
 // Static.
 int64 BookmarkChangeProcessor::UpdateSyncNode(
@@ skipping 22 matching lines @@
 
 void BookmarkChangeProcessor::BookmarkMetaInfoChanged(
     BookmarkModel* model, const BookmarkNode* node) {
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkChangeProcessor::BookmarkNodeMoved(BookmarkModel* model,
       const BookmarkNode* old_parent, int old_index,
       const BookmarkNode* new_parent, int new_index) {
   const BookmarkNode* child = new_parent->GetChild(new_index);
+
+  if (!CanSyncNode(child))
+    return;
+
   // We shouldn't see changes to the top-level nodes.
   if (model->is_permanent_node(child)) {
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
 
   int64 new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
@@ skipping 25 matching lines @@
 }
 
 void BookmarkChangeProcessor::BookmarkNodeFaviconChanged(
     BookmarkModel* model,
     const BookmarkNode* node) {
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkChangeProcessor::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
+  if (!CanSyncNode(node))
+    return;
   int64 new_version = syncer::syncable::kInvalidTransactionVersion;
   std::vector<const BookmarkNode*> children;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
 
     // The given node's children got reordered. We need to reorder all the
     // children of the corresponding sync node.
     for (int i = 0; i < node->child_count(); ++i) {
       const BookmarkNode* child = node->GetChild(i);
@@ skipping 455 matching lines @@
   if (favicon_bytes.get() && favicon_bytes->size()) {
     sync_pb::BookmarkSpecifics updated_specifics(
         sync_node->GetBookmarkSpecifics());
     updated_specifics.set_favicon(favicon_bytes->front(),
                                   favicon_bytes->size());
     updated_specifics.set_icon_url(bookmark_node->icon_url().spec());
     sync_node->SetBookmarkSpecifics(updated_specifics);
   }
 }
 
+bool BookmarkChangeProcessor::CanSyncNode(const BookmarkNode* node) {
+  return bookmark_model_->client()->CanSyncNode(node);
+}
+
 }  // namespace browser_sync