[Sync] Move //components/sync to the syncer namespace.

components/sync_bookmarks/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 "components/sync_bookmarks/bookmark_change_processor.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <stack>
@@ skipping 25 matching lines @@
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
 using syncer::ChangeRecord;
 using syncer::ChangeRecordList;
 
 namespace sync_bookmarks {
 
 static const char kMobileBookmarksTag[] = "synced_bookmarks";
 
 BookmarkChangeProcessor::BookmarkChangeProcessor(
-    sync_driver::SyncClient* sync_client,
+    syncer::SyncClient* sync_client,
     BookmarkModelAssociator* model_associator,
     std::unique_ptr<syncer::DataTypeErrorHandler> err_handler)
-    : sync_driver::ChangeProcessor(std::move(err_handler)),
+    : syncer::ChangeProcessor(std::move(err_handler)),
       bookmark_model_(NULL),
       sync_client_(sync_client),
       model_associator_(model_associator) {
   DCHECK(model_associator);
   DCHECK(sync_client);
   DCHECK(error_handler());
 }
 
 BookmarkChangeProcessor::~BookmarkChangeProcessor() {
   if (bookmark_model_)
@@ skipping 697 matching lines @@
   // bookmark model to mark as synced.
   model->SetNodeSyncTransactionVersion(model->root_node(), model_version);
 }
 
 // Static.
 // Update a bookmark node with specified sync data.
 void BookmarkChangeProcessor::UpdateBookmarkWithSyncData(
     const syncer::BaseNode& sync_node,
     BookmarkModel* model,
     const BookmarkNode* node,
-    sync_driver::SyncClient* sync_client) {
+    syncer::SyncClient* sync_client) {
   DCHECK_EQ(sync_node.GetIsFolder(), node->is_folder());
   const sync_pb::BookmarkSpecifics& specifics =
       sync_node.GetBookmarkSpecifics();
   if (!sync_node.GetIsFolder())
     model->SetURL(node, GURL(specifics.url()));
   model->SetTitle(node, base::UTF8ToUTF16(sync_node.GetTitle()));
   if (specifics.has_creation_time_us()) {
     model->SetDateAdded(
         node,
         base::Time::FromInternalValue(specifics.creation_time_us()));
@@ skipping 15 matching lines @@
   }
 }
 
 // static
 // Creates a bookmark node under the given parent node from the given sync
 // node. Returns the newly created node.
 const BookmarkNode* BookmarkChangeProcessor::CreateBookmarkNode(
     const syncer::BaseNode* sync_node,
     const BookmarkNode* parent,
     BookmarkModel* model,
-    sync_driver::SyncClient* sync_client,
+    syncer::SyncClient* sync_client,
     int index) {
   return CreateBookmarkNode(base::UTF8ToUTF16(sync_node->GetTitle()),
                             GURL(sync_node->GetBookmarkSpecifics().url()),
                             sync_node, parent, model, sync_client, index);
 }
 
 // static
 // Creates a bookmark node under the given parent node from the given sync
 // node. Returns the newly created node.
 const BookmarkNode* BookmarkChangeProcessor::CreateBookmarkNode(
     const base::string16& title,
     const GURL& url,
     const syncer::BaseNode* sync_node,
     const BookmarkNode* parent,
     BookmarkModel* model,
-    sync_driver::SyncClient* sync_client,
+    syncer::SyncClient* sync_client,
     int index) {
   DCHECK(parent);
 
   const BookmarkNode* node;
   if (sync_node->GetIsFolder()) {
     node = model->AddFolderWithMetaInfo(parent, index, title,
                                         GetBookmarkMetaInfo(sync_node).get());
   } else {
     // 'creation_time_us' was added in m24. Assume a time of 0 means now.
     const sync_pb::BookmarkSpecifics& specifics =
@@ skipping 10 matching lines @@
 
   return node;
 }
 
 // static
 // Sets the favicon of the given bookmark node from the given sync node.
 bool BookmarkChangeProcessor::SetBookmarkFavicon(
     const syncer::BaseNode* sync_node,
     const BookmarkNode* bookmark_node,
     BookmarkModel* bookmark_model,
-    sync_driver::SyncClient* sync_client) {
+    syncer::SyncClient* sync_client) {
   const sync_pb::BookmarkSpecifics& specifics =
       sync_node->GetBookmarkSpecifics();
   const std::string& icon_bytes_str = specifics.favicon();
   if (icon_bytes_str.empty())
     return false;
 
   scoped_refptr<base::RefCountedString> icon_bytes(
       new base::RefCountedString());
   icon_bytes->data().assign(icon_bytes_str);
   GURL icon_url(specifics.icon_url());
@@ skipping 68 matching lines @@
       meta_info->set_value(it->second);
     }
   }
 
   sync_node->SetBookmarkSpecifics(specifics);
 }
 
 // static
 void BookmarkChangeProcessor::ApplyBookmarkFavicon(
     const BookmarkNode* bookmark_node,
-    sync_driver::SyncClient* sync_client,
+    syncer::SyncClient* sync_client,
     const GURL& icon_url,
     const scoped_refptr<base::RefCountedMemory>& bitmap_data) {
   history::HistoryService* history = sync_client->GetHistoryService();
   favicon::FaviconService* favicon_service = sync_client->GetFaviconService();
 
   history->AddPageNoVisitForBookmark(bookmark_node->url(),
                                      bookmark_node->GetTitle());
   // The client may have cached the favicon at 2x. Use MergeFavicon() as not to
   // overwrite the cached 2x favicon bitmap. Sync favicons are always
   // gfx::kFaviconSize in width and height. Store the favicon into history
@@ skipping 21 matching lines @@
     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 sync_bookmarks