bookmarks: Remove Profile getter accessor from BookmarkModel.

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 <stack>
 #include <vector>
 
 #include "base/location.h"
@@ skipping 40 matching lines @@
   DCHECK(error_handler);
 }
 
 BookmarkChangeProcessor::~BookmarkChangeProcessor() {
   if (bookmark_model_)
     bookmark_model_->RemoveObserver(this);
 }
 
 void BookmarkChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(profile);
+  profile_ = profile;
   DCHECK(!bookmark_model_);
   bookmark_model_ = BookmarkModelFactory::GetForProfile(profile);
   DCHECK(bookmark_model_->IsLoaded());
   bookmark_model_->AddObserver(this);
 }
 
 void BookmarkChangeProcessor::UpdateSyncNodeProperties(
     const BookmarkNode* src,
     BookmarkModel* model,
     syncer::WriteNode* dst) {
@@ skipping 469 matching lines @@
       passed_deletes = true;
 
       syncer::ReadNode src(trans);
       if (src.InitByIdLookup(it->id) != syncer::BaseNode::INIT_OK) {
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
             "ApplyModelChanges was passed a bad ID");
         return;
       }
 
       const BookmarkNode* node = CreateOrUpdateBookmarkNode(&src, model,
+                                                            profile_,
                                                             model_associator_);
       if (node) {
         bookmark_model_->SetNodeMetaInfo(node, kBookmarkTransactionVersionKey,
                                          base::Int64ToString(model_version));
       } else {
         // Because the Synced Bookmarks node can be created server side, it's
         // possible it'll arrive at the client as an update. In that case it
         // won't have been associated at startup, the GetChromeNodeFromSyncId
         // call above will return NULL, and we won't detect it as a permanent
         // node, resulting in us trying to create it here (which will
@@ skipping 35 matching lines @@
   model->SetNodeMetaInfo(model->root_node(), kBookmarkTransactionVersionKey,
                          base::Int64ToString(model_version));
 }
 
 // Static.
 // Create a bookmark node corresponding to |src| if one is not already
 // associated with |src|.
 const BookmarkNode* BookmarkChangeProcessor::CreateOrUpdateBookmarkNode(
     syncer::BaseNode* src,
     BookmarkModel* model,
+    Profile* profile,
     BookmarkModelAssociator* model_associator) {
   const BookmarkNode* parent =
       model_associator->GetChromeNodeFromSyncId(src->GetParentId());
   if (!parent) {
     DLOG(WARNING) << "Could not find parent of node being added/updated."
       << " Node title: " << src->GetTitle()
       << ", parent id = " << src->GetParentId();
 
     return NULL;
   }
   int index = CalculateBookmarkModelInsertionIndex(parent,
                                                    src,
                                                    model_associator);
   const BookmarkNode* dst = model_associator->GetChromeNodeFromSyncId(
       src->GetId());
   if (!dst) {
-    dst = CreateBookmarkNode(src, parent, model, index);
+    dst = CreateBookmarkNode(src, parent, model, profile, index);
     if (dst)
       model_associator->Associate(dst, src->GetId());
   } else {
     // URL and is_folder are not expected to change.
     // TODO(ncarter): Determine if such changes should be legal or not.
     DCHECK_EQ(src->GetIsFolder(), dst->is_folder());
 
     // Handle reparenting and/or repositioning.
     model->Move(dst, parent, index);
 
     const sync_pb::BookmarkSpecifics& specifics = src->GetBookmarkSpecifics();
     if (!src->GetIsFolder())
       model->SetURL(dst, GURL(specifics.url()));
     model->SetTitle(dst, UTF8ToUTF16(src->GetTitle()));
     if (specifics.has_creation_time_us()) {
       model->SetDateAdded(dst,
                           base::Time::FromInternalValue(
                               specifics.creation_time_us()));
     }
 
-    SetBookmarkFavicon(src, dst, model);
+    SetBookmarkFavicon(src, dst, model, profile);
   }
 
   return dst;
 }
 
 // static
 void BookmarkChangeProcessor::UpdateTransactionVersion(
     int64 new_version,
     BookmarkModel* model,
     const std::vector<const BookmarkNode*>& nodes) {
   if (new_version != syncer::syncable::kInvalidTransactionVersion) {
     model->SetNodeMetaInfo(model->root_node(), kBookmarkTransactionVersionKey,
                            base::Int64ToString(new_version));
     for (size_t i = 0; i < nodes.size(); ++i) {
       model->SetNodeMetaInfo(nodes[i], kBookmarkTransactionVersionKey,
                              base::Int64ToString(new_version));
     }
   }
 }
 
 // static
 // Creates a bookmark node under the given parent node from the given sync
 // node. Returns the newly created node.
 const BookmarkNode* BookmarkChangeProcessor::CreateBookmarkNode(
     syncer::BaseNode* sync_node,
     const BookmarkNode* parent,
     BookmarkModel* model,
+    Profile* profile,
     int index) {
   DCHECK(parent);
   DCHECK(index >= 0 && index <= parent->child_count());
 
   const BookmarkNode* node;
   if (sync_node->GetIsFolder()) {
     node = model->AddFolder(parent, index,
                             UTF8ToUTF16(sync_node->GetTitle()));
   } else {
     // 'creation_time_us' was added in m24. Assume a time of 0 means now.
     const sync_pb::BookmarkSpecifics& specifics =
         sync_node->GetBookmarkSpecifics();
     const int64 create_time_internal = specifics.creation_time_us();
     base::Time create_time = (create_time_internal == 0) ?
         base::Time::Now() : base::Time::FromInternalValue(create_time_internal);
     node = model->AddURLWithCreationTime(parent, index,
                                          UTF8ToUTF16(sync_node->GetTitle()),
                                          GURL(specifics.url()), create_time);
     if (node)
-      SetBookmarkFavicon(sync_node, node, model);
+      SetBookmarkFavicon(sync_node, node, model, profile);
   }
   return node;
 }
 
 // static
 // Sets the favicon of the given bookmark node from the given sync node.
 bool BookmarkChangeProcessor::SetBookmarkFavicon(
     syncer::BaseNode* sync_node,
     const BookmarkNode* bookmark_node,
-    BookmarkModel* bookmark_model) {
+    BookmarkModel* bookmark_model,
+    Profile* profile) {
   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());
 
   // Old clients may not be syncing the favicon URL. If the icon URL is not
   // synced, use the page URL as a fake icon URL as it is guaranteed to be
   // unique.
   if (icon_url.is_empty())
     icon_url = bookmark_node->url();
 
-  ApplyBookmarkFavicon(bookmark_node, bookmark_model->profile(), icon_url,
-                       icon_bytes);
+  ApplyBookmarkFavicon(bookmark_node, profile, icon_url, icon_bytes);
 
   return true;
 }
 
 // static
 void BookmarkChangeProcessor::ApplyBookmarkFavicon(
     const BookmarkNode* bookmark_node,
     Profile* profile,
     const GURL& icon_url,
     const scoped_refptr<base::RefCountedMemory>& bitmap_data) {
@@ skipping 27 matching lines @@
     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);
   }
 }
 
 }  // namespace browser_sync