Change ownership of BookmarkClient

components/bookmarks/browser/bookmark_model.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_
 #define COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
-#include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 
 class PrefService;
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
+struct UserMetricsAction;
 }
 
 namespace favicon_base {
 struct FaviconImageResult;
 }
 
 namespace query_parser {
 enum class MatchingAlgorithm;
 }
 
 namespace bookmarks {
 
+class BookmarkClient;
 class BookmarkCodecTest;
 class BookmarkExpandedStateTracker;
 class BookmarkIndex;
+class BookmarkIndexTest;
 class BookmarkLoadDetails;
+struct BookmarkMatch;
 class BookmarkModelObserver;
 class BookmarkStorage;
 class ScopedGroupBookmarkActions;
 class TestBookmarkClient;
-struct BookmarkMatch;
 
 // BookmarkModel --------------------------------------------------------------
 
 // BookmarkModel provides a directed acyclic graph of URLs and folders.
 // Three graphs are provided for the three entry points: those on the 'bookmarks
 // bar', those in the 'other bookmarks' folder and those in the 'mobile' folder.
 //
 // An observer may be attached to observe relevant events.
 //
 // You should NOT directly create a BookmarkModel, instead go through the
 // BookmarkModelFactory.
 class BookmarkModel : public KeyedService {
  public:
   struct URLAndTitle {
     GURL url;
     base::string16 title;
   };
 
-  explicit BookmarkModel(BookmarkClient* client);
+  explicit BookmarkModel(scoped_ptr<BookmarkClient> bookmark_client);
   ~BookmarkModel() override;
 
   // KeyedService:
   void Shutdown() override;
 
   // Loads the bookmarks. This is called upon creation of the
   // BookmarkModel. You need not invoke this directly.
   // All load operations will be executed on |io_task_runner| and the completion
   // callback will be called from |ui_task_runner|.
   void Load(PrefService* pref_service,
@@ skipping 23 matching lines @@
   const BookmarkNode* managed_node() const { return managed_node_; }
 
   // The top-level supervised bookmarks folder, defined by the custodian of a
   // supervised user. This is null until loaded.
   const BookmarkNode* supervised_node() const { return supervised_node_; }
 
   bool is_root_node(const BookmarkNode* node) const { return node == &root_; }
 
   // Returns whether the given |node| is one of the permanent nodes - root node,
   // 'bookmark bar' node, 'other' node or 'mobile' node, or one of the root
-  // nodes supplied by the |client_|.
+  // nodes supplied by the |bookmark_client_|.
   bool is_permanent_node(const BookmarkNode* node) const {
     return node && (node == &root_ || node->parent() == &root_);
   }
 
   // Returns the parent the last node was added to. This never returns NULL
   // (as long as the model is loaded).
   const BookmarkNode* GetParentForNewNodes();
 
   void AddObserver(BookmarkModelObserver* observer);
   void RemoveObserver(BookmarkModelObserver* observer);
@@ skipping 188 matching lines @@
 
   // Returns true if this node can be edited by the user.
   // TODO(joaodasilva): the model should check this more aggressively, and
   // should give the client a means to temporarily disable those checks.
   // http://crbug.com/49598
   bool CanBeEditedByUser(const BookmarkNode* node);
 
   // Returns true if the permanent node |node| should always be visible.
   bool IsPermanentNodeVisible(const BookmarkPermanentNode* node);
 
-  // Forward the |action| to |client_| to record it. See
+  // Forward the |action| to |bookmark_client_| to record it. See
   // BookmarkClient::RecordAction for more information.
   void RecordAction(const base::UserMetricsAction& action);
 
  private:
   friend class BookmarkCodecTest;
+  friend class BookmarkIndexTest;
   friend class BookmarkStorage;
   friend class ScopedGroupBookmarkActions;
   friend class TestBookmarkClient;
 
   // Used to order BookmarkNodes by URL.
   class NodeURLComparator {
    public:
     bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) const {
       return n1->url() < n2->url();
     }
@@ skipping 87 matching lines @@
 
   // Returns whether the permanent node is a top-level permanent node.
   bool IsTopLevelPermanentNode(const BookmarkPermanentNode* node);
 
   // Returns true if the permanent node can have its title updated.
   bool CanSetPermanentNodeTitle(const BookmarkNode* node);
 
   // Returns true if touch icons are preferred over favicons.
   bool PreferTouchIcon();
 
-  BookmarkClient* const client_;
+  scoped_ptr<BookmarkClient> bookmark_client_;
 
   // Whether the initial set of data has been loaded.
   bool loaded_;
 
   // The root node. This contains the bookmark bar node, the 'other' node and
   // the mobile node as children.
   BookmarkNode root_;
 
   BookmarkPermanentNode* bookmark_bar_node_;
   BookmarkPermanentNode* other_node_;
@@ skipping 31 matching lines @@
   scoped_ptr<BookmarkExpandedStateTracker> expanded_state_tracker_;
 
   std::set<std::string> non_cloned_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
 };
 
 }  // namespace bookmarks
 
 #endif  // COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_