diff options
43 files changed, 876 insertions, 537 deletions
diff --git a/chrome/browser/android/bookmarks/bookmarks_bridge.cc b/chrome/browser/android/bookmarks/bookmarks_bridge.cc index faf417e..7e07b41 100644 --- a/chrome/browser/android/bookmarks/bookmarks_bridge.cc +++ b/chrome/browser/android/bookmarks/bookmarks_bridge.cc @@ -10,8 +10,8 @@ #include "base/i18n/string_compare.h" #include "base/prefs/pref_service.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" #include "chrome/browser/bookmarks/enhanced_bookmarks_features.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/profiles/incognito_helpers.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/profiles/profile_android.h" @@ -23,6 +23,7 @@ #include "components/bookmarks/browser/bookmark_utils.h" #include "components/bookmarks/browser/scoped_group_bookmark_actions.h" #include "components/bookmarks/common/android/bookmark_type.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/query_parser/query_parser.h" #include "components/signin/core/browser/signin_manager.h" #include "components/undo/bookmark_undo_service.h" @@ -90,17 +91,16 @@ scoped_ptr<icu::Collator> GetICUCollator() { } // namespace -BookmarksBridge::BookmarksBridge(JNIEnv* env, - jobject obj, - jobject j_profile) +BookmarksBridge::BookmarksBridge(JNIEnv* env, jobject obj, jobject j_profile) : weak_java_ref_(env, obj), bookmark_model_(NULL), - client_(NULL), + managed_bookmark_service_(NULL), partner_bookmarks_shim_(NULL) { DCHECK_CURRENTLY_ON(BrowserThread::UI); profile_ = ProfileAndroid::FromProfileAndroid(j_profile); bookmark_model_ = BookmarkModelFactory::GetForProfile(profile_); - client_ = ChromeBookmarkClientFactory::GetForProfile(profile_); + managed_bookmark_service_ = + ManagedBookmarkServiceFactory::GetForProfile(profile_); // Registers the notifications we are interested. bookmark_model_->AddObserver(this); @@ -224,13 +224,13 @@ void BookmarksBridge::GetTopLevelFolderIDs(JNIEnv* env, std::vector<const BookmarkNode*> top_level_folders; if (get_special) { - if (client_->managed_node() && - client_->managed_node()->child_count() > 0) { - top_level_folders.push_back(client_->managed_node()); + if (managed_bookmark_service_->managed_node() && + managed_bookmark_service_->managed_node()->child_count() > 0) { + top_level_folders.push_back(managed_bookmark_service_->managed_node()); } - if (client_->supervised_node() && - client_->supervised_node()->child_count() > 0) { - top_level_folders.push_back(client_->supervised_node()); + if (managed_bookmark_service_->supervised_node() && + managed_bookmark_service_->supervised_node()->child_count() > 0) { + top_level_folders.push_back(managed_bookmark_service_->supervised_node()); } if (partner_bookmarks_shim_->HasPartnerBookmarks() && IsReachable(partner_bookmarks_shim_->GetPartnerBookmarksRoot())) { @@ -325,8 +325,10 @@ void BookmarksBridge::GetAllFoldersWithDepths(JNIEnv* env, bookmarkList.clear(); for (int i = 0; i < node->child_count(); ++i) { const BookmarkNode* child = node->GetChild(i); - if (child->is_folder() && client_->CanBeEditedByUser(child)) + if (child->is_folder() && + managed_bookmark_service_->CanBeEditedByUser(child)) { bookmarkList.push_back(node->GetChild(i)); + } } std::stable_sort(bookmarkList.begin(), bookmarkList.end(), @@ -448,8 +450,10 @@ void BookmarksBridge::GetAllBookmarkIDsOrderedByCreationDate( for (int i = 0; i < (*folder_iter)->child_count(); ++i) { const BookmarkNode* child = (*folder_iter)->GetChild(i); if (!IsReachable(child) || - bookmarks::IsDescendantOf(child, client_->managed_node()) || - bookmarks::IsDescendantOf(child, client_->supervised_node())) { + bookmarks::IsDescendantOf( + child, managed_bookmark_service_->managed_node()) || + bookmarks::IsDescendantOf( + child, managed_bookmark_service_->supervised_node())) { continue; } @@ -773,8 +777,8 @@ const BookmarkNode* BookmarksBridge::GetFolderWithFallback(long folder_id, const BookmarkNode* folder = GetNodeByID(folder_id, type); if (!folder || folder->type() == BookmarkNode::URL || !IsFolderAvailable(folder)) { - if (!client_->managed_node()->empty()) - folder = client_->managed_node(); + if (!managed_bookmark_service_->managed_node()->empty()) + folder = managed_bookmark_service_->managed_node(); else folder = bookmark_model_->mobile_node(); } @@ -790,11 +794,12 @@ bool BookmarksBridge::IsEditable(const BookmarkNode* node) const { return false; if (partner_bookmarks_shim_->IsPartnerBookmark(node)) return partner_bookmarks_shim_->IsEditable(node); - return client_->CanBeEditedByUser(node); + return managed_bookmark_service_->CanBeEditedByUser(node); } bool BookmarksBridge::IsManaged(const BookmarkNode* node) const { - return bookmarks::IsDescendantOf(node, client_->managed_node()); + return bookmarks::IsDescendantOf(node, + managed_bookmark_service_->managed_node()); } const BookmarkNode* BookmarksBridge::GetParentNode(const BookmarkNode* node) { @@ -827,11 +832,11 @@ bool BookmarksBridge::IsFolderAvailable( const BookmarkNode* folder) const { // The managed bookmarks folder is not shown if there are no bookmarks // configured via policy. - if (folder == client_->managed_node() && folder->empty()) + if (folder == managed_bookmark_service_->managed_node() && folder->empty()) return false; // Similarly, the supervised bookmarks folder is not shown if there are no // bookmarks configured by the custodian. - if (folder == client_->supervised_node() && folder->empty()) + if (folder == managed_bookmark_service_->supervised_node() && folder->empty()) return false; SigninManager* signin = SigninManagerFactory::GetForProfile( diff --git a/chrome/browser/android/bookmarks/bookmarks_bridge.h b/chrome/browser/android/bookmarks/bookmarks_bridge.h index 7fdbd5d..7b4e211 100644 --- a/chrome/browser/android/bookmarks/bookmarks_bridge.h +++ b/chrome/browser/android/bookmarks/bookmarks_bridge.h @@ -12,11 +12,12 @@ #include "base/basictypes.h" #include "base/compiler_specific.h" #include "chrome/browser/android/bookmarks/partner_bookmarks_shim.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" #include "components/bookmarks/browser/base_bookmark_model_observer.h" #include "components/bookmarks/common/android/bookmark_id.h" namespace bookmarks { +class BookmarkModel; +class ManagedBookmarkService; class ScopedGroupBookmarkActions; } @@ -212,7 +213,7 @@ class BookmarksBridge : public bookmarks::BaseBookmarkModelObserver, Profile* profile_; JavaObjectWeakGlobalRef weak_java_ref_; bookmarks::BookmarkModel* bookmark_model_; // weak - ChromeBookmarkClient* client_; // weak + bookmarks::ManagedBookmarkService* managed_bookmark_service_; // weak scoped_ptr<bookmarks::ScopedGroupBookmarkActions> grouped_bookmark_actions_; // Information about the Partner bookmarks (must check for IsLoaded()). diff --git a/chrome/browser/android/provider/chrome_browser_provider.cc b/chrome/browser/android/provider/chrome_browser_provider.cc index 08d23ab..9040bae 100644 --- a/chrome/browser/android/provider/chrome_browser_provider.cc +++ b/chrome/browser/android/provider/chrome_browser_provider.cc @@ -20,8 +20,7 @@ #include "chrome/browser/android/provider/bookmark_model_observer_task.h" #include "chrome/browser/android/provider/run_on_ui_thread_blocking.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/favicon/favicon_service_factory.h" #include "chrome/browser/history/android/sqlite_cursor.h" @@ -32,6 +31,7 @@ #include "chrome/browser/search_engines/template_url_service_factory.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/favicon/core/favicon_service.h" #include "components/history/core/browser/android/android_history_types.h" #include "components/history/core/browser/history_service.h" @@ -58,6 +58,7 @@ using base::android::ScopedJavaGlobalRef; using base::android::ScopedJavaLocalRef; using bookmarks::BookmarkModel; using bookmarks::BookmarkNode; +using bookmarks::ManagedBookmarkService; using content::BrowserThread; // After refactoring the following class hierarchy has been created in order @@ -480,17 +481,19 @@ class CreateBookmarksFolderOnceTask : public BookmarkModelTask { // Creates a Java BookmarkNode object for a node given its id. class GetEditableBookmarkFoldersTask : public BookmarkModelTask { public: - GetEditableBookmarkFoldersTask(ChromeBookmarkClient* client, - BookmarkModel* model) - : BookmarkModelTask(model), client_(client) {} + GetEditableBookmarkFoldersTask( + ManagedBookmarkService* managed_bookmark_service, + BookmarkModel* model) + : BookmarkModelTask(model), + managed_bookmark_service_(managed_bookmark_service) {} void Run(ScopedJavaGlobalRef<jobject>* jroot) { RunOnUIThreadBlocking::Run( base::Bind(&GetEditableBookmarkFoldersTask::RunOnUIThread, - client_, model(), jroot)); + managed_bookmark_service_, model(), jroot)); } - static void RunOnUIThread(ChromeBookmarkClient* client, + static void RunOnUIThread(ManagedBookmarkService* managed, BookmarkModel* model, ScopedJavaGlobalRef<jobject>* jroot) { DCHECK_CURRENTLY_ON(BrowserThread::UI); @@ -500,12 +503,12 @@ class GetEditableBookmarkFoldersTask : public BookmarkModelTask { // The iterative approach is not possible because ScopedGlobalJavaRefs // cannot be copy-constructed, and therefore not used in STL containers. - ConvertFolderSubtree(client, AttachCurrentThread(), root, + ConvertFolderSubtree(managed, AttachCurrentThread(), root, ScopedJavaLocalRef<jobject>(), jroot); } private: - static void ConvertFolderSubtree(ChromeBookmarkClient* client, + static void ConvertFolderSubtree(ManagedBookmarkService* managed, JNIEnv* env, const BookmarkNode* node, const JavaRef<jobject>& parent_folder, @@ -520,9 +523,9 @@ class GetEditableBookmarkFoldersTask : public BookmarkModelTask { for (int i = 0; i < node->child_count(); ++i) { const BookmarkNode* child = node->GetChild(i); - if (child->is_folder() && client->CanBeEditedByUser(child)) { + if (child->is_folder() && managed->CanBeEditedByUser(child)) { ScopedJavaGlobalRef<jobject> jchild; - ConvertFolderSubtree(client, env, child, *jfolder, &jchild); + ConvertFolderSubtree(managed, env, child, *jfolder, &jchild); Java_BookmarkNode_addChild(env, jfolder->obj(), jchild.obj()); if (ClearException(env)) { @@ -533,7 +536,7 @@ class GetEditableBookmarkFoldersTask : public BookmarkModelTask { } } - ChromeBookmarkClient* client_; + ManagedBookmarkService* managed_bookmark_service_; DISALLOW_COPY_AND_ASSIGN(GetEditableBookmarkFoldersTask); }; @@ -1504,10 +1507,10 @@ ScopedJavaLocalRef<jobject> ChromeBrowserProvider::GetEditableBookmarkFolders( JNIEnv* env, jobject obj) { ScopedJavaGlobalRef<jobject> jroot; - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); + ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_); - GetEditableBookmarkFoldersTask task(client, model); + GetEditableBookmarkFoldersTask task(managed, model); task.Run(&jroot); return ScopedJavaLocalRef<jobject>(jroot); } diff --git a/chrome/browser/android/tab_android.cc b/chrome/browser/android/tab_android.cc index e696c83..77cbeec 100644 --- a/chrome/browser/android/tab_android.cc +++ b/chrome/browser/android/tab_android.cc @@ -14,8 +14,7 @@ #include "chrome/browser/android/compositor/tab_content_manager.h" #include "chrome/browser/android/metrics/uma_utils.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/browser_about_handler.h" #include "chrome/browser/chrome_notification_types.h" #include "chrome/browser/content_settings/tab_specific_content_settings.h" @@ -51,6 +50,7 @@ #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_node.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/dom_distiller/core/url_utils.h" #include "components/favicon/content/content_favicon_driver.h" #include "components/infobars/core/infobar_container.h" @@ -770,8 +770,8 @@ jlong TabAndroid::GetBookmarkId(JNIEnv* env, // Get all the nodes for |url| and sort them by date added. std::vector<const bookmarks::BookmarkNode*> nodes; - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile); bookmarks::BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile); model->GetNodesByURL(url, &nodes); @@ -779,7 +779,7 @@ jlong TabAndroid::GetBookmarkId(JNIEnv* env, // Return the first node matching the search criteria. for (size_t i = 0; i < nodes.size(); ++i) { - if (only_editable && !client->CanBeEditedByUser(nodes[i])) + if (only_editable && !managed->CanBeEditedByUser(nodes[i])) continue; return nodes[i]->id(); } diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.cc b/chrome/browser/bookmarks/chrome_bookmark_client.cc index 8f11940..671aa64 100644 --- a/chrome/browser/bookmarks/chrome_bookmark_client.cc +++ b/chrome/browser/bookmarks/chrome_bookmark_client.cc @@ -10,13 +10,11 @@ #include "base/values.h" #include "chrome/browser/favicon/favicon_service_factory.h" #include "chrome/browser/history/history_service_factory.h" -#include "chrome/browser/policy/profile_policy_connector.h" -#include "chrome/browser/policy/profile_policy_connector_factory.h" #include "chrome/browser/profiles/profile.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_node.h" #include "components/bookmarks/browser/bookmark_utils.h" -#include "components/bookmarks/managed/managed_bookmarks_tracker.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/favicon/core/favicon_service.h" #include "components/history/core/browser/history_service.h" #include "components/history/core/browser/url_database.h" @@ -28,11 +26,6 @@ #include "policy/policy_constants.h" #include "ui/base/l10n/l10n_util.h" -using bookmarks::BookmarkModel; -using bookmarks::BookmarkNode; -using bookmarks::BookmarkPermanentNode; -using bookmarks::ManagedBookmarksTracker; - namespace { void RunCallbackWithImage( @@ -49,53 +42,40 @@ void RunCallbackWithImage( callback.Run(result); } -void LoadInitialContents(BookmarkPermanentNode* node, - base::ListValue* initial_bookmarks, - int64* next_node_id) { - // Load the initial contents of the |node| now, and assign it an unused ID. - int64 id = *next_node_id; - node->set_id(id); - *next_node_id = ManagedBookmarksTracker::LoadInitial( - node, initial_bookmarks, id + 1); - node->set_visible(!node->empty()); +bool IsPermanentNode( + const bookmarks::BookmarkPermanentNode* node, + bookmarks::ManagedBookmarkService* managed_bookmark_service) { + bookmarks::BookmarkNode::Type type = node->type(); + if (type == bookmarks::BookmarkNode::BOOKMARK_BAR || + type == bookmarks::BookmarkNode::OTHER_NODE || + type == bookmarks::BookmarkNode::MOBILE) { + return true; + } + + if (!managed_bookmark_service) + return false; + + return node == managed_bookmark_service->managed_node() || + node == managed_bookmark_service->supervised_node(); } } // namespace -ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile) - : profile_(profile), - model_(nullptr), - managed_node_(nullptr), - supervised_node_(nullptr) { -} +ChromeBookmarkClient::ChromeBookmarkClient( + Profile* profile, + bookmarks::ManagedBookmarkService* managed_bookmark_service) + : profile_(profile), managed_bookmark_service_(managed_bookmark_service) {} ChromeBookmarkClient::~ChromeBookmarkClient() { } -void ChromeBookmarkClient::Init(BookmarkModel* model) { - DCHECK(model); - DCHECK(!model_); - model_ = model; - model_->AddObserver(this); - - managed_bookmarks_tracker_.reset(new ManagedBookmarksTracker( - model_, - profile_->GetPrefs(), - false, - base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain, - base::Unretained(this)))); - supervised_bookmarks_tracker_.reset(new ManagedBookmarksTracker( - model_, - profile_->GetPrefs(), - true, - base::Callback<std::string()>())); +void ChromeBookmarkClient::Init(bookmarks::BookmarkModel* model) { + if (managed_bookmark_service_) + managed_bookmark_service_->BookmarkModelCreated(model); } void ChromeBookmarkClient::Shutdown() { - if (model_) { - model_->RemoveObserver(this); - model_ = nullptr; - } + managed_bookmark_service_ = nullptr; BookmarkClient::Shutdown(); } @@ -159,18 +139,17 @@ void ChromeBookmarkClient::GetTypedCountForNodes( } bool ChromeBookmarkClient::IsPermanentNodeVisible( - const BookmarkPermanentNode* node) { - DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR || - node->type() == BookmarkNode::OTHER_NODE || - node->type() == BookmarkNode::MOBILE || - node == managed_node_ || - node == supervised_node_); - if (node == managed_node_ || node == supervised_node_) + const bookmarks::BookmarkPermanentNode* node) { + DCHECK(IsPermanentNode(node, managed_bookmark_service_)); + if (managed_bookmark_service_ && + (node == managed_bookmark_service_->managed_node() || + node == managed_bookmark_service_->supervised_node())) { return false; + } #if defined(OS_IOS) || defined(OS_ANDROID) - return node->type() == BookmarkNode::MOBILE; + return node->type() == bookmarks::BookmarkNode::MOBILE; #else - return node->type() != BookmarkNode::MOBILE; + return node->type() != bookmarks::BookmarkNode::MOBILE; #endif } @@ -179,89 +158,29 @@ void ChromeBookmarkClient::RecordAction(const base::UserMetricsAction& action) { } bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() { - // Create the managed_node_ and supervised_node_ with a temporary ID of 0 now. - // They will be populated (and assigned proper IDs) in the LoadExtraNodes - // callback. - // The ownership of managed_node_ and supervised_node_ is in limbo until - // LoadExtraNodes runs, so we leave them in the care of the closure meanwhile. - scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0)); - managed_node_ = managed.get(); - scoped_ptr<BookmarkPermanentNode> supervised(new BookmarkPermanentNode(0)); - supervised_node_ = supervised.get(); + if (!managed_bookmark_service_) + return bookmarks::LoadExtraCallback(); - return base::Bind( - &ChromeBookmarkClient::LoadExtraNodes, - base::Passed(&managed), - base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()), - base::Passed(&supervised), - base::Passed( - supervised_bookmarks_tracker_->GetInitialManagedBookmarks())); + return managed_bookmark_service_->GetLoadExtraNodesCallback(); } bool ChromeBookmarkClient::CanSetPermanentNodeTitle( - const BookmarkNode* permanent_node) { - // The |managed_node_| can have its title updated if the user signs in or - // out, since the name of the managed domain can appear in it. - // Also, both |managed_node_| and |supervised_node_| can have their title - // updated on locale changes (crbug.com/459448). - return (!bookmarks::IsDescendantOf(permanent_node, managed_node_) && - !bookmarks::IsDescendantOf(permanent_node, supervised_node_)) || - permanent_node == managed_node_ || - permanent_node == supervised_node_; -} - -bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) { - return !bookmarks::IsDescendantOf(node, managed_node_) && - !bookmarks::IsDescendantOf(node, supervised_node_); -} - -bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) { - return !bookmarks::IsDescendantOf(node, managed_node_) && - !bookmarks::IsDescendantOf(node, supervised_node_); -} - -void ChromeBookmarkClient::BookmarkModelChanged() { + const bookmarks::BookmarkNode* permanent_node) { + return !managed_bookmark_service_ + ? true + : managed_bookmark_service_->CanSetPermanentNodeTitle( + permanent_node); } -void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model, - bool ids_reassigned) { - BaseBookmarkModelObserver::BookmarkModelLoaded(model, ids_reassigned); - // Start tracking the managed and supervised bookmarks. This will detect any - // changes that may have occurred while the initial managed and supervised - // bookmarks were being loaded on the background. - managed_bookmarks_tracker_->Init(managed_node_); - supervised_bookmarks_tracker_->Init(supervised_node_); -} - -// static -bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes( - scoped_ptr<BookmarkPermanentNode> managed_node, - scoped_ptr<base::ListValue> initial_managed_bookmarks, - scoped_ptr<BookmarkPermanentNode> supervised_node, - scoped_ptr<base::ListValue> initial_supervised_bookmarks, - int64* next_node_id) { - LoadInitialContents( - managed_node.get(), initial_managed_bookmarks.get(), next_node_id); - managed_node->SetTitle(l10n_util::GetStringUTF16( - IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME)); - - LoadInitialContents( - supervised_node.get(), initial_supervised_bookmarks.get(), next_node_id); - supervised_node->SetTitle(l10n_util::GetStringUTF16( - IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME)); - - bookmarks::BookmarkPermanentNodeList extra_nodes; - // Ownership of the managed and supervised nodes passed to the caller. - extra_nodes.push_back(managed_node.release()); - extra_nodes.push_back(supervised_node.release()); - - return extra_nodes.Pass(); +bool ChromeBookmarkClient::CanSyncNode(const bookmarks::BookmarkNode* node) { + return !managed_bookmark_service_ + ? true + : managed_bookmark_service_->CanSyncNode(node); } -std::string ChromeBookmarkClient::GetManagedBookmarksDomain() { - policy::ProfilePolicyConnector* connector = - policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile_); - if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks)) - return connector->GetManagementDomain(); - return std::string(); +bool ChromeBookmarkClient::CanBeEditedByUser( + const bookmarks::BookmarkNode* node) { + return !managed_bookmark_service_ + ? true + : managed_bookmark_service_->CanBeEditedByUser(node); } diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.h b/chrome/browser/bookmarks/chrome_bookmark_client.h index 683ebeb..3fdde2c 100644 --- a/chrome/browser/bookmarks/chrome_bookmark_client.h +++ b/chrome/browser/bookmarks/chrome_bookmark_client.h @@ -10,7 +10,6 @@ #include "base/deferred_sequenced_task_runner.h" #include "base/macros.h" -#include "components/bookmarks/browser/base_bookmark_model_observer.h" #include "components/bookmarks/browser/bookmark_client.h" class GURL; @@ -24,13 +23,14 @@ namespace bookmarks { class BookmarkModel; class BookmarkNode; class BookmarkPermanentNode; -class ManagedBookmarksTracker; +class ManagedBookmarkService; } -class ChromeBookmarkClient : public bookmarks::BookmarkClient, - public bookmarks::BaseBookmarkModelObserver { +class ChromeBookmarkClient : public bookmarks::BookmarkClient { public: - explicit ChromeBookmarkClient(Profile* profile); + ChromeBookmarkClient( + Profile* profile, + bookmarks::ManagedBookmarkService* managed_bookmark_service); ~ChromeBookmarkClient() override; void Init(bookmarks::BookmarkModel* model); @@ -38,12 +38,6 @@ class ChromeBookmarkClient : public bookmarks::BookmarkClient, // KeyedService: void Shutdown() override; - // The top-level managed bookmarks folder, defined by an enterprise policy. - const bookmarks::BookmarkNode* managed_node() { return managed_node_; } - // The top-level supervised bookmarks folder, defined by the custodian of a - // supervised user. - const bookmarks::BookmarkNode* supervised_node() { return supervised_node_; } - // bookmarks::BookmarkClient: bool PreferTouchIcon() override; base::CancelableTaskTracker::TaskId GetFaviconImageForPageURL( @@ -65,40 +59,12 @@ class ChromeBookmarkClient : public bookmarks::BookmarkClient, bool CanBeEditedByUser(const bookmarks::BookmarkNode* node) override; private: - // bookmarks::BaseBookmarkModelObserver: - void BookmarkModelChanged() override; - - // bookmarks::BookmarkModelObserver: - void BookmarkModelLoaded(bookmarks::BookmarkModel* model, - bool ids_reassigned) override; - - // Helper for GetLoadExtraNodesCallback(). - static bookmarks::BookmarkPermanentNodeList LoadExtraNodes( - scoped_ptr<bookmarks::BookmarkPermanentNode> managed_node, - scoped_ptr<base::ListValue> initial_managed_bookmarks, - scoped_ptr<bookmarks::BookmarkPermanentNode> supervised_node, - scoped_ptr<base::ListValue> initial_supervised_bookmarks, - int64* next_node_id); - - // Returns the management domain that configured the managed bookmarks, - // or an empty string. - std::string GetManagedBookmarksDomain(); - + // Pointer to the associated Profile. Must outlive ChromeBookmarkClient. Profile* profile_; - // Pointer to the BookmarkModel. Will be non-NULL from the call to Init to - // the call to Shutdown. Must be valid for the whole interval. - bookmarks::BookmarkModel* model_; - - // Managed bookmarks are defined by an enterprise policy. - scoped_ptr<bookmarks::ManagedBookmarksTracker> managed_bookmarks_tracker_; - // The top-level managed bookmarks folder. - bookmarks::BookmarkPermanentNode* managed_node_; - - // Supervised bookmarks are defined by the custodian of a supervised user. - scoped_ptr<bookmarks::ManagedBookmarksTracker> supervised_bookmarks_tracker_; - // The top-level supervised bookmarks folder. - bookmarks::BookmarkPermanentNode* supervised_node_; + // Pointer to the ManagedBookmarkService responsible for bookmark policy. May + // be null during testing. + bookmarks::ManagedBookmarkService* managed_bookmark_service_; DISALLOW_COPY_AND_ASSIGN(ChromeBookmarkClient); }; diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc b/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc index b97488f..2626f78 100644 --- a/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc +++ b/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc @@ -6,10 +6,23 @@ #include "base/memory/singleton.h" #include "chrome/browser/bookmarks/chrome_bookmark_client.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/profiles/incognito_helpers.h" #include "chrome/browser/profiles/profile.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/keyed_service/content/browser_context_dependency_manager.h" +namespace { + +scoped_ptr<KeyedService> BuildChromeBookmarkClient( + content::BrowserContext* context) { + Profile* profile = Profile::FromBrowserContext(context); + return make_scoped_ptr(new ChromeBookmarkClient( + profile, ManagedBookmarkServiceFactory::GetForProfile(profile))); +} + +} // namespace + // static ChromeBookmarkClient* ChromeBookmarkClientFactory::GetForProfile( Profile* profile) { @@ -22,10 +35,17 @@ ChromeBookmarkClientFactory* ChromeBookmarkClientFactory::GetInstance() { return Singleton<ChromeBookmarkClientFactory>::get(); } +// static +BrowserContextKeyedServiceFactory::TestingFactoryFunction +ChromeBookmarkClientFactory::GetDefaultFactory() { + return &BuildChromeBookmarkClient; +} + ChromeBookmarkClientFactory::ChromeBookmarkClientFactory() : BrowserContextKeyedServiceFactory( "ChromeBookmarkClient", BrowserContextDependencyManager::GetInstance()) { + DependsOn(ManagedBookmarkServiceFactory::GetInstance()); } ChromeBookmarkClientFactory::~ChromeBookmarkClientFactory() { @@ -33,7 +53,7 @@ ChromeBookmarkClientFactory::~ChromeBookmarkClientFactory() { KeyedService* ChromeBookmarkClientFactory::BuildServiceInstanceFor( content::BrowserContext* context) const { - return new ChromeBookmarkClient(static_cast<Profile*>(context)); + return BuildChromeBookmarkClient(context).release(); } content::BrowserContext* ChromeBookmarkClientFactory::GetBrowserContextToUse( diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_factory.h b/chrome/browser/bookmarks/chrome_bookmark_client_factory.h index 597728bb..a5971f6 100644 --- a/chrome/browser/bookmarks/chrome_bookmark_client_factory.h +++ b/chrome/browser/bookmarks/chrome_bookmark_client_factory.h @@ -19,8 +19,8 @@ class Profile; class ChromeBookmarkClientFactory : public BrowserContextKeyedServiceFactory { public: static ChromeBookmarkClient* GetForProfile(Profile* profile); - static ChromeBookmarkClientFactory* GetInstance(); + static TestingFactoryFunction GetDefaultFactory(); private: friend struct DefaultSingletonTraits<ChromeBookmarkClientFactory>; diff --git a/chrome/browser/bookmarks/managed_bookmark_service_factory.cc b/chrome/browser/bookmarks/managed_bookmark_service_factory.cc new file mode 100644 index 0000000..ffeafb3 --- /dev/null +++ b/chrome/browser/bookmarks/managed_bookmark_service_factory.cc @@ -0,0 +1,78 @@ +// Copyright 2015 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/bookmarks/managed_bookmark_service_factory.h" + +#include <string> + +#include "base/bind.h" +#include "base/memory/singleton.h" +#include "chrome/browser/policy/profile_policy_connector.h" +#include "chrome/browser/policy/profile_policy_connector_factory.h" +#include "chrome/browser/profiles/incognito_helpers.h" +#include "chrome/browser/profiles/profile.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" +#include "components/keyed_service/content/browser_context_dependency_manager.h" +#include "policy/policy_constants.h" + +namespace { + +std::string GetManagedBookmarksDomain(Profile* profile) { + policy::ProfilePolicyConnector* connector = + policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile); + if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks)) + return connector->GetManagementDomain(); + return std::string(); +} + +scoped_ptr<KeyedService> BuildManagedBookmarkService( + content::BrowserContext* context) { + Profile* profile = Profile::FromBrowserContext(context); + return make_scoped_ptr(new bookmarks::ManagedBookmarkService( + profile->GetPrefs(), + base::Bind(&GetManagedBookmarksDomain, base::Unretained(profile)))); +} + +} // namespace + +// static +bookmarks::ManagedBookmarkService* ManagedBookmarkServiceFactory::GetForProfile( + Profile* profile) { + return static_cast<bookmarks::ManagedBookmarkService*>( + GetInstance()->GetServiceForBrowserContext(profile, true)); +} + +// static +ManagedBookmarkServiceFactory* ManagedBookmarkServiceFactory::GetInstance() { + return Singleton<ManagedBookmarkServiceFactory>::get(); +} + +// static +BrowserContextKeyedServiceFactory::TestingFactoryFunction +ManagedBookmarkServiceFactory::GetDefaultFactory() { + return &BuildManagedBookmarkService; +} + +ManagedBookmarkServiceFactory::ManagedBookmarkServiceFactory() + : BrowserContextKeyedServiceFactory( + "ManagedBookmarkService", + BrowserContextDependencyManager::GetInstance()) { + DependsOn(policy::ProfilePolicyConnectorFactory::GetInstance()); +} + +ManagedBookmarkServiceFactory::~ManagedBookmarkServiceFactory() {} + +KeyedService* ManagedBookmarkServiceFactory::BuildServiceInstanceFor( + content::BrowserContext* context) const { + return BuildManagedBookmarkService(context).release(); +} + +content::BrowserContext* ManagedBookmarkServiceFactory::GetBrowserContextToUse( + content::BrowserContext* context) const { + return chrome::GetBrowserContextRedirectedInIncognito(context); +} + +bool ManagedBookmarkServiceFactory::ServiceIsNULLWhileTesting() const { + return true; +} diff --git a/chrome/browser/bookmarks/managed_bookmark_service_factory.h b/chrome/browser/bookmarks/managed_bookmark_service_factory.h new file mode 100644 index 0000000..af1e102 --- /dev/null +++ b/chrome/browser/bookmarks/managed_bookmark_service_factory.h @@ -0,0 +1,44 @@ +// Copyright 2015 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 CHROME_BROWSER_BOOKMARKS_MANAGED_BOOKMARK_SERVICE_FACTORY_H_ +#define CHROME_BROWSER_BOOKMARKS_MANAGED_BOOKMARK_SERVICE_FACTORY_H_ + +#include "base/macros.h" +#include "base/memory/scoped_ptr.h" +#include "components/keyed_service/content/browser_context_keyed_service_factory.h" + +template <typename T> +struct DefaultSingletonTraits; +class Profile; + +namespace bookmarks { +class ManagedBookmarkService; +} + +// Singleton that owns all ManagedBookmarkServices and associates them with +// Profile. +class ManagedBookmarkServiceFactory : public BrowserContextKeyedServiceFactory { + public: + static bookmarks::ManagedBookmarkService* GetForProfile(Profile* profile); + static ManagedBookmarkServiceFactory* GetInstance(); + static TestingFactoryFunction GetDefaultFactory(); + + private: + friend struct DefaultSingletonTraits<ManagedBookmarkServiceFactory>; + + ManagedBookmarkServiceFactory(); + ~ManagedBookmarkServiceFactory() override; + + // BrowserStateKeyedServiceFactory implementation. + KeyedService* BuildServiceInstanceFor( + content::BrowserContext* context) const override; + content::BrowserContext* GetBrowserContextToUse( + content::BrowserContext* context) const override; + bool ServiceIsNULLWhileTesting() const override; + + DISALLOW_COPY_AND_ASSIGN(ManagedBookmarkServiceFactory); +}; + +#endif // CHROME_BROWSER_BOOKMARKS_MANAGED_BOOKMARK_SERVICE_FACTORY_H_ diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_unittest.cc b/chrome/browser/bookmarks/managed_bookmark_service_unittest.cc index 6a6dd17..b37ccaa 100644 --- a/chrome/browser/bookmarks/chrome_bookmark_client_unittest.cc +++ b/chrome/browser/bookmarks/managed_bookmark_service_unittest.cc @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "base/macros.h" #include "base/memory/scoped_ptr.h" @@ -10,7 +10,7 @@ #include "base/values.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" #include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/test/base/testing_pref_service_syncable.h" #include "chrome/test/base/testing_profile.h" #include "components/bookmarks/browser/bookmark_model.h" @@ -27,13 +27,14 @@ using bookmarks::BookmarkModel; using bookmarks::BookmarkNode; +using bookmarks::ManagedBookmarkService; using testing::Mock; using testing::_; -class ChromeBookmarkClientTest : public testing::Test { +class ManagedBookmarkServiceTest : public testing::Test { public: - ChromeBookmarkClientTest() : client_(NULL), model_(NULL) {} - ~ChromeBookmarkClientTest() override {} + ManagedBookmarkServiceTest() : managed_(NULL), model_(NULL) {} + ~ManagedBookmarkServiceTest() override {} void SetUp() override { prefs_ = profile_.GetTestingPrefService(); @@ -44,9 +45,9 @@ class ChromeBookmarkClientTest : public testing::Test { ResetModel(); // The managed node always exists. - ASSERT_TRUE(client_->managed_node()); - ASSERT_TRUE(client_->managed_node()->parent() == model_->root_node()); - EXPECT_NE(-1, model_->root_node()->GetIndexOf(client_->managed_node())); + ASSERT_TRUE(managed_->managed_node()); + ASSERT_TRUE(managed_->managed_node()->parent() == model_->root_node()); + EXPECT_NE(-1, model_->root_node()->GetIndexOf(managed_->managed_node())); } void TearDown() override { model_->RemoveObserver(&observer_); } @@ -56,8 +57,8 @@ class ChromeBookmarkClientTest : public testing::Test { model_ = BookmarkModelFactory::GetForProfile(&profile_); bookmarks::test::WaitForBookmarkModelToLoad(model_); model_->AddObserver(&observer_); - client_ = ChromeBookmarkClientFactory::GetForProfile(&profile_); - DCHECK(client_); + managed_ = ManagedBookmarkServiceFactory::GetForProfile(&profile_); + DCHECK(managed_); } static base::DictionaryValue* CreateBookmark(const std::string& title, @@ -132,36 +133,36 @@ class ChromeBookmarkClientTest : public testing::Test { TestingProfile profile_; TestingPrefServiceSyncable* prefs_; bookmarks::MockBookmarkModelObserver observer_; - ChromeBookmarkClient* client_; + ManagedBookmarkService* managed_; BookmarkModel* model_; - DISALLOW_COPY_AND_ASSIGN(ChromeBookmarkClientTest); + DISALLOW_COPY_AND_ASSIGN(ManagedBookmarkServiceTest); }; -TEST_F(ChromeBookmarkClientTest, EmptyManagedNode) { +TEST_F(ManagedBookmarkServiceTest, EmptyManagedNode) { // Verifies that the managed node is empty and invisible when the policy is // not set. model_->RemoveObserver(&observer_); prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks); ResetModel(); - ASSERT_TRUE(client_->managed_node()); - EXPECT_TRUE(client_->managed_node()->empty()); - EXPECT_FALSE(client_->managed_node()->IsVisible()); + ASSERT_TRUE(managed_->managed_node()); + EXPECT_TRUE(managed_->managed_node()->empty()); + EXPECT_FALSE(managed_->managed_node()->IsVisible()); } -TEST_F(ChromeBookmarkClientTest, LoadInitial) { +TEST_F(ManagedBookmarkServiceTest, LoadInitial) { // Verifies that the initial load picks up the initial policy too. EXPECT_TRUE(model_->bookmark_bar_node()->empty()); EXPECT_TRUE(model_->other_node()->empty()); - EXPECT_FALSE(client_->managed_node()->empty()); - EXPECT_TRUE(client_->managed_node()->IsVisible()); + EXPECT_FALSE(managed_->managed_node()->empty()); + EXPECT_TRUE(managed_->managed_node()->IsVisible()); scoped_ptr<base::DictionaryValue> expected(CreateExpectedTree()); - EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get())); + EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get())); } -TEST_F(ChromeBookmarkClientTest, SwapNodes) { +TEST_F(ManagedBookmarkServiceTest, SwapNodes) { // Swap the Google bookmark with the Folder. scoped_ptr<base::ListValue> updated(CreateTestTree()); scoped_ptr<base::Value> removed; @@ -169,7 +170,7 @@ TEST_F(ChromeBookmarkClientTest, SwapNodes) { updated->Append(removed.release()); // These two nodes should just be swapped. - const BookmarkNode* parent = client_->managed_node(); + const BookmarkNode* parent = managed_->managed_node(); EXPECT_CALL(observer_, BookmarkNodeMoved(model_, parent, 1, parent, 0)); prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks, updated->DeepCopy()); @@ -178,15 +179,15 @@ TEST_F(ChromeBookmarkClientTest, SwapNodes) { // Verify the final tree. scoped_ptr<base::DictionaryValue> expected( CreateFolder(GetManagedFolderTitle(), updated.release())); - EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get())); + EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get())); } -TEST_F(ChromeBookmarkClientTest, RemoveNode) { +TEST_F(ManagedBookmarkServiceTest, RemoveNode) { // Remove the Folder. scoped_ptr<base::ListValue> updated(CreateTestTree()); ASSERT_TRUE(updated->Remove(1, NULL)); - const BookmarkNode* parent = client_->managed_node(); + const BookmarkNode* parent = managed_->managed_node(); EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _)); prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks, updated->DeepCopy()); @@ -195,10 +196,10 @@ TEST_F(ChromeBookmarkClientTest, RemoveNode) { // Verify the final tree. scoped_ptr<base::DictionaryValue> expected( CreateFolder(GetManagedFolderTitle(), updated.release())); - EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get())); + EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get())); } -TEST_F(ChromeBookmarkClientTest, CreateNewNodes) { +TEST_F(ManagedBookmarkServiceTest, CreateNewNodes) { // Put all the nodes inside another folder. scoped_ptr<base::ListValue> updated(new base::ListValue); updated->Append(CreateFolder("Container", CreateTestTree())); @@ -206,9 +207,8 @@ TEST_F(ChromeBookmarkClientTest, CreateNewNodes) { EXPECT_CALL(observer_, BookmarkNodeAdded(model_, _, _)).Times(5); // The remaining nodes have been pushed to positions 1 and 2; they'll both be // removed when at position 1. - const BookmarkNode* parent = client_->managed_node(); - EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _)) - .Times(2); + const BookmarkNode* parent = managed_->managed_node(); + EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _)).Times(2); prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks, updated->DeepCopy()); Mock::VerifyAndClearExpectations(&observer_); @@ -216,83 +216,79 @@ TEST_F(ChromeBookmarkClientTest, CreateNewNodes) { // Verify the final tree. scoped_ptr<base::DictionaryValue> expected( CreateFolder(GetManagedFolderTitle(), updated.release())); - EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get())); + EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get())); } -TEST_F(ChromeBookmarkClientTest, RemoveAllUserBookmarks) { +TEST_F(ManagedBookmarkServiceTest, RemoveAllUserBookmarks) { // Remove the policy. - const BookmarkNode* parent = client_->managed_node(); - EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 0, _, _)) - .Times(2); + const BookmarkNode* parent = managed_->managed_node(); + EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 0, _, _)).Times(2); prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks); Mock::VerifyAndClearExpectations(&observer_); - EXPECT_TRUE(client_->managed_node()->empty()); - EXPECT_FALSE(client_->managed_node()->IsVisible()); + EXPECT_TRUE(managed_->managed_node()->empty()); + EXPECT_FALSE(managed_->managed_node()->IsVisible()); } -TEST_F(ChromeBookmarkClientTest, IsDescendantOfManagedNode) { - EXPECT_FALSE(bookmarks::IsDescendantOf(model_->root_node(), - client_->managed_node())); +TEST_F(ManagedBookmarkServiceTest, IsDescendantOfManagedNode) { + EXPECT_FALSE( + bookmarks::IsDescendantOf(model_->root_node(), managed_->managed_node())); EXPECT_FALSE(bookmarks::IsDescendantOf(model_->bookmark_bar_node(), - client_->managed_node())); + managed_->managed_node())); EXPECT_FALSE(bookmarks::IsDescendantOf(model_->other_node(), - client_->managed_node())); + managed_->managed_node())); EXPECT_FALSE(bookmarks::IsDescendantOf(model_->mobile_node(), - client_->managed_node())); - EXPECT_TRUE(bookmarks::IsDescendantOf(client_->managed_node(), - client_->managed_node())); + managed_->managed_node())); + EXPECT_TRUE(bookmarks::IsDescendantOf(managed_->managed_node(), + managed_->managed_node())); - const BookmarkNode* parent = client_->managed_node(); + const BookmarkNode* parent = managed_->managed_node(); ASSERT_EQ(2, parent->child_count()); - EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(0), - client_->managed_node())); - EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(1), - client_->managed_node())); + EXPECT_TRUE( + bookmarks::IsDescendantOf(parent->GetChild(0), managed_->managed_node())); + EXPECT_TRUE( + bookmarks::IsDescendantOf(parent->GetChild(1), managed_->managed_node())); parent = parent->GetChild(1); ASSERT_EQ(2, parent->child_count()); - EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(0), - client_->managed_node())); - EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(1), - client_->managed_node())); + EXPECT_TRUE( + bookmarks::IsDescendantOf(parent->GetChild(0), managed_->managed_node())); + EXPECT_TRUE( + bookmarks::IsDescendantOf(parent->GetChild(1), managed_->managed_node())); } -TEST_F(ChromeBookmarkClientTest, RemoveAllDoesntRemoveManaged) { - EXPECT_EQ(2, client_->managed_node()->child_count()); +TEST_F(ManagedBookmarkServiceTest, RemoveAllDoesntRemoveManaged) { + EXPECT_EQ(2, managed_->managed_node()->child_count()); EXPECT_CALL(observer_, BookmarkNodeAdded(model_, model_->bookmark_bar_node(), 0)); EXPECT_CALL(observer_, BookmarkNodeAdded(model_, model_->bookmark_bar_node(), 1)); - model_->AddURL(model_->bookmark_bar_node(), - 0, - base::ASCIIToUTF16("Test"), + model_->AddURL(model_->bookmark_bar_node(), 0, base::ASCIIToUTF16("Test"), GURL("http://google.com/")); - model_->AddFolder( - model_->bookmark_bar_node(), 1, base::ASCIIToUTF16("Test Folder")); + model_->AddFolder(model_->bookmark_bar_node(), 1, + base::ASCIIToUTF16("Test Folder")); EXPECT_EQ(2, model_->bookmark_bar_node()->child_count()); Mock::VerifyAndClearExpectations(&observer_); EXPECT_CALL(observer_, BookmarkAllUserNodesRemoved(model_, _)); model_->RemoveAllUserBookmarks(); - EXPECT_EQ(2, client_->managed_node()->child_count()); + EXPECT_EQ(2, managed_->managed_node()->child_count()); EXPECT_EQ(0, model_->bookmark_bar_node()->child_count()); Mock::VerifyAndClearExpectations(&observer_); } -TEST_F(ChromeBookmarkClientTest, HasDescendantsOfManagedNode) { - const BookmarkNode* user_node = model_->AddURL(model_->other_node(), - 0, - base::ASCIIToUTF16("foo bar"), - GURL("http://www.google.com")); - const BookmarkNode* managed_node = client_->managed_node()->GetChild(0); +TEST_F(ManagedBookmarkServiceTest, HasDescendantsOfManagedNode) { + const BookmarkNode* user_node = + model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("foo bar"), + GURL("http://www.google.com")); + const BookmarkNode* managed_node = managed_->managed_node()->GetChild(0); ASSERT_TRUE(managed_node); std::vector<const BookmarkNode*> nodes; - EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, client_->managed_node())); + EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node())); nodes.push_back(user_node); - EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, client_->managed_node())); + EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node())); nodes.push_back(managed_node); - EXPECT_TRUE(bookmarks::HasDescendantsOf(nodes, client_->managed_node())); + EXPECT_TRUE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node())); } diff --git a/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc b/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc index 640cd00..7820372 100644 --- a/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc +++ b/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc @@ -14,7 +14,6 @@ #include "base/values.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" #include "chrome/browser/bookmarks/bookmark_stats.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/enhanced_bookmarks/enhanced_bookmark_model_factory.h" #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h" @@ -30,6 +29,7 @@ #include "components/bookmarks/browser/bookmark_node_data.h" #include "components/bookmarks/browser/bookmark_utils.h" #include "components/bookmarks/browser/scoped_group_bookmark_actions.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/enhanced_bookmarks/enhanced_bookmark_model.h" #include "components/undo/bookmark_undo_service.h" #include "components/user_prefs/user_prefs.h" @@ -365,10 +365,10 @@ void BookmarkManagerPrivateDragEventRouter::ClearBookmarkNodeData() { bool ClipboardBookmarkManagerFunction::CopyOrCut(bool cut, const std::vector<std::string>& id_list) { BookmarkModel* model = GetBookmarkModel(); - ChromeBookmarkClient* client = GetChromeBookmarkClient(); + bookmarks::ManagedBookmarkService* managed = GetManagedBookmarkService(); std::vector<const BookmarkNode*> nodes; EXTENSION_FUNCTION_VALIDATE(GetNodesFromVector(model, id_list, &nodes)); - if (cut && bookmarks::HasDescendantsOf(nodes, client->managed_node())) { + if (cut && bookmarks::HasDescendantsOf(nodes, managed->managed_node())) { error_ = bookmark_keys::kModifyManagedError; return false; } @@ -633,11 +633,11 @@ bool BookmarkManagerPrivateGetSubtreeFunction::RunOnReady() { } std::vector<linked_ptr<api::bookmarks::BookmarkTreeNode> > nodes; - ChromeBookmarkClient* client = GetChromeBookmarkClient(); + bookmarks::ManagedBookmarkService* managed = GetManagedBookmarkService(); if (params->folders_only) - bookmark_api_helpers::AddNodeFoldersOnly(client, node, &nodes, true); + bookmark_api_helpers::AddNodeFoldersOnly(managed, node, &nodes, true); else - bookmark_api_helpers::AddNode(client, node, &nodes, true); + bookmark_api_helpers::AddNode(managed, node, &nodes, true); results_ = GetSubtree::Results::Create(nodes); return true; } @@ -669,8 +669,8 @@ bool BookmarkManagerPrivateCreateWithMetaInfoFunction::RunOnReady() { return false; scoped_ptr<api::bookmarks::BookmarkTreeNode> result_node( - bookmark_api_helpers::GetBookmarkTreeNode( - GetChromeBookmarkClient(), node, false, false)); + bookmark_api_helpers::GetBookmarkTreeNode(GetManagedBookmarkService(), + node, false, false)); results_ = CreateWithMetaInfo::Results::Create(*result_node); return true; @@ -797,13 +797,13 @@ bool BookmarkManagerPrivateRemoveTreesFunction::RunOnReady() { EXTENSION_FUNCTION_VALIDATE(params); BookmarkModel* model = GetBookmarkModel(); - ChromeBookmarkClient* client = GetChromeBookmarkClient(); + bookmarks::ManagedBookmarkService* managed = GetManagedBookmarkService(); bookmarks::ScopedGroupBookmarkActions group_deletes(model); int64 id; for (size_t i = 0; i < params->id_list.size(); ++i) { if (!GetBookmarkIdAsInt64(params->id_list[i], &id)) return false; - if (!bookmark_api_helpers::RemoveNode(model, client, id, true, &error_)) + if (!bookmark_api_helpers::RemoveNode(model, managed, id, true, &error_)) return false; } diff --git a/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc b/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc index 5fedf2d..effa74c 100644 --- a/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc +++ b/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc @@ -9,14 +9,14 @@ #include "base/strings/utf_string_conversions.h" #include "base/values.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/extensions/extension_apitest.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ui/browser.h" #include "chrome/common/pref_names.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/common/bookmark_pref_names.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/bookmarks/test/bookmark_test_helpers.h" #include "components/user_prefs/user_prefs.h" @@ -33,8 +33,8 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_BookmarkManager) { // Add managed bookmarks. Profile* profile = browser()->profile(); BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile); - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile); bookmarks::test::WaitForBookmarkModelToLoad(model); base::ListValue list; @@ -47,7 +47,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_BookmarkManager) { node->Set("children", new base::ListValue()); list.Append(node); profile->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list); - ASSERT_EQ(2, client->managed_node()->child_count()); + ASSERT_EQ(2, managed->managed_node()->child_count()); ASSERT_TRUE(RunComponentExtensionTest("bookmark_manager/standard")) << message_; diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc index 4e0fa04..0708c15 100644 --- a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc +++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc @@ -9,11 +9,11 @@ #include "base/strings/string_number_conversions.h" #include "base/strings/utf_string_conversions.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h" #include "chrome/common/extensions/api/bookmarks.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" using bookmarks::BookmarkModel; using bookmarks::BookmarkNode; @@ -27,26 +27,25 @@ namespace bookmark_api_helpers { namespace { -void AddNodeHelper(ChromeBookmarkClient* client, +void AddNodeHelper(bookmarks::ManagedBookmarkService* managed, const BookmarkNode* node, - std::vector<linked_ptr<BookmarkTreeNode> >* nodes, + std::vector<linked_ptr<BookmarkTreeNode>>* nodes, bool recurse, bool only_folders) { if (node->IsVisible()) { - linked_ptr<BookmarkTreeNode> new_node(GetBookmarkTreeNode(client, - node, - recurse, - only_folders)); + linked_ptr<BookmarkTreeNode> new_node( + GetBookmarkTreeNode(managed, node, recurse, only_folders)); nodes->push_back(new_node); } } } // namespace -BookmarkTreeNode* GetBookmarkTreeNode(ChromeBookmarkClient* client, - const BookmarkNode* node, - bool recurse, - bool only_folders) { +BookmarkTreeNode* GetBookmarkTreeNode( + bookmarks::ManagedBookmarkService* managed, + const BookmarkNode* node, + bool recurse, + bool only_folders) { BookmarkTreeNode* bookmark_tree_node = new BookmarkTreeNode; bookmark_tree_node->id = base::Int64ToString(node->id()); @@ -76,44 +75,44 @@ BookmarkTreeNode* GetBookmarkTreeNode(ChromeBookmarkClient* client, new double(floor(node->date_added().ToDoubleT() * 1000))); } - if (bookmarks::IsDescendantOf(node, client->managed_node()) || - bookmarks::IsDescendantOf(node, client->supervised_node())) { + if (bookmarks::IsDescendantOf(node, managed->managed_node()) || + bookmarks::IsDescendantOf(node, managed->supervised_node())) { bookmark_tree_node->unmodifiable = api::bookmarks::BOOKMARK_TREE_NODE_UNMODIFIABLE_MANAGED; } if (recurse && node->is_folder()) { - std::vector<linked_ptr<BookmarkTreeNode> > children; + std::vector<linked_ptr<BookmarkTreeNode>> children; for (int i = 0; i < node->child_count(); ++i) { const BookmarkNode* child = node->GetChild(i); if (child->IsVisible() && (!only_folders || child->is_folder())) { linked_ptr<BookmarkTreeNode> child_node( - GetBookmarkTreeNode(client, child, true, only_folders)); + GetBookmarkTreeNode(managed, child, true, only_folders)); children.push_back(child_node); } } bookmark_tree_node->children.reset( - new std::vector<linked_ptr<BookmarkTreeNode> >(children)); + new std::vector<linked_ptr<BookmarkTreeNode>>(children)); } return bookmark_tree_node; } -void AddNode(ChromeBookmarkClient* client, +void AddNode(bookmarks::ManagedBookmarkService* managed, const BookmarkNode* node, - std::vector<linked_ptr<BookmarkTreeNode> >* nodes, + std::vector<linked_ptr<BookmarkTreeNode>>* nodes, bool recurse) { - return AddNodeHelper(client, node, nodes, recurse, false); + return AddNodeHelper(managed, node, nodes, recurse, false); } -void AddNodeFoldersOnly(ChromeBookmarkClient* client, +void AddNodeFoldersOnly(bookmarks::ManagedBookmarkService* managed, const BookmarkNode* node, - std::vector<linked_ptr<BookmarkTreeNode> >* nodes, + std::vector<linked_ptr<BookmarkTreeNode>>* nodes, bool recurse) { - return AddNodeHelper(client, node, nodes, recurse, true); + return AddNodeHelper(managed, node, nodes, recurse, true); } bool RemoveNode(BookmarkModel* model, - ChromeBookmarkClient* client, + bookmarks::ManagedBookmarkService* managed, int64 id, bool recursive, std::string* error) { @@ -126,8 +125,8 @@ bool RemoveNode(BookmarkModel* model, *error = keys::kModifySpecialError; return false; } - if (bookmarks::IsDescendantOf(node, client->managed_node()) || - bookmarks::IsDescendantOf(node, client->supervised_node())) { + if (bookmarks::IsDescendantOf(node, managed->managed_node()) || + bookmarks::IsDescendantOf(node, managed->supervised_node())) { *error = keys::kModifyManagedError; return false; } diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h index e128501..dc32387 100644 --- a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h +++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h @@ -11,11 +11,10 @@ #include "base/basictypes.h" #include "chrome/common/extensions/api/bookmarks.h" -class ChromeBookmarkClient; - namespace bookmarks { class BookmarkModel; class BookmarkNode; +class ManagedBookmarkService; } // Helper functions. @@ -24,25 +23,27 @@ namespace bookmark_api_helpers { // The returned value is owned by the caller. api::bookmarks::BookmarkTreeNode* GetBookmarkTreeNode( - ChromeBookmarkClient* client, + bookmarks::ManagedBookmarkService* managed, const bookmarks::BookmarkNode* node, bool recurse, bool only_folders); -// Add a JSON representation of |node| to the JSON |nodes|. -void AddNode(ChromeBookmarkClient* client, +// Adds a JSON representation of |node| to the JSON |nodes|. +void AddNode(bookmarks::ManagedBookmarkService* managed, const bookmarks::BookmarkNode* node, - std::vector<linked_ptr<api::bookmarks::BookmarkTreeNode> >* nodes, + std::vector<linked_ptr<api::bookmarks::BookmarkTreeNode>>* nodes, bool recurse); -void AddNodeFoldersOnly(ChromeBookmarkClient* client, - const bookmarks::BookmarkNode* node, - std::vector<linked_ptr< - api::bookmarks::BookmarkTreeNode> >* nodes, - bool recurse); +// Adds a JSON representation of |node| of folder type to the JSON |nodes|. +void AddNodeFoldersOnly( + bookmarks::ManagedBookmarkService* managed, + const bookmarks::BookmarkNode* node, + std::vector<linked_ptr<api::bookmarks::BookmarkTreeNode>>* nodes, + bool recurse); +// Remove node of |id|. bool RemoveNode(bookmarks::BookmarkModel* model, - ChromeBookmarkClient* client, + bookmarks::ManagedBookmarkService* managed, int64 id, bool recursive, std::string* error); diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc index bca84de..c2e76c3 100644 --- a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc +++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc @@ -9,12 +9,12 @@ #include "base/strings/utf_string_conversions.h" #include "base/values.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h" #include "chrome/common/extensions/api/bookmarks.h" #include "chrome/test/base/testing_profile.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/bookmarks/test/bookmark_test_helpers.h" #include "content/public/test/test_browser_thread_bundle.h" #include "testing/gtest/include/gtest/gtest.h" @@ -32,12 +32,16 @@ namespace bookmark_api_helpers { class ExtensionBookmarksTest : public testing::Test { public: ExtensionBookmarksTest() - : client_(NULL), model_(NULL), node_(NULL), node2_(NULL), folder_(NULL) {} + : managed_(NULL), + model_(NULL), + node_(NULL), + node2_(NULL), + folder_(NULL) {} void SetUp() override { profile_.CreateBookmarkModel(false); model_ = BookmarkModelFactory::GetForProfile(&profile_); - client_ = ChromeBookmarkClientFactory::GetForProfile(&profile_); + managed_ = ManagedBookmarkServiceFactory::GetForProfile(&profile_); bookmarks::test::WaitForBookmarkModelToLoad(model_); node_ = model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("Digg"), @@ -60,7 +64,7 @@ class ExtensionBookmarksTest : public testing::Test { content::TestBrowserThreadBundle thread_bundle_; TestingProfile profile_; - ChromeBookmarkClient* client_; + bookmarks::ManagedBookmarkService* managed_; BookmarkModel* model_; const BookmarkNode* node_; const BookmarkNode* node2_; @@ -69,7 +73,7 @@ class ExtensionBookmarksTest : public testing::Test { TEST_F(ExtensionBookmarksTest, GetFullTreeFromRoot) { scoped_ptr<BookmarkTreeNode> tree( - GetBookmarkTreeNode(client_, + GetBookmarkTreeNode(managed_, model_->other_node(), true, // Recurse. false)); // Not only folders. @@ -78,7 +82,7 @@ TEST_F(ExtensionBookmarksTest, GetFullTreeFromRoot) { TEST_F(ExtensionBookmarksTest, GetFoldersOnlyFromRoot) { scoped_ptr<BookmarkTreeNode> tree( - GetBookmarkTreeNode(client_, + GetBookmarkTreeNode(managed_, model_->other_node(), true, // Recurse. true)); // Only folders. @@ -87,7 +91,7 @@ TEST_F(ExtensionBookmarksTest, GetFoldersOnlyFromRoot) { TEST_F(ExtensionBookmarksTest, GetSubtree) { scoped_ptr<BookmarkTreeNode> tree( - GetBookmarkTreeNode(client_, + GetBookmarkTreeNode(managed_, folder_, true, // Recurse. false)); // Not only folders. @@ -99,7 +103,7 @@ TEST_F(ExtensionBookmarksTest, GetSubtree) { TEST_F(ExtensionBookmarksTest, GetSubtreeFoldersOnly) { scoped_ptr<BookmarkTreeNode> tree( - GetBookmarkTreeNode(client_, + GetBookmarkTreeNode(managed_, folder_, true, // Recurse. true)); // Only folders. @@ -111,7 +115,7 @@ TEST_F(ExtensionBookmarksTest, GetSubtreeFoldersOnly) { TEST_F(ExtensionBookmarksTest, GetModifiableNode) { scoped_ptr<BookmarkTreeNode> tree( - GetBookmarkTreeNode(client_, + GetBookmarkTreeNode(managed_, node_, false, // Recurse. false)); // Only folders. @@ -124,12 +128,12 @@ TEST_F(ExtensionBookmarksTest, GetModifiableNode) { TEST_F(ExtensionBookmarksTest, GetManagedNode) { const BookmarkNode* managed_bookmark = - model_->AddURL(client_->managed_node(), + model_->AddURL(managed_->managed_node(), 0, base::ASCIIToUTF16("Chromium"), GURL("http://www.chromium.org/")); scoped_ptr<BookmarkTreeNode> tree( - GetBookmarkTreeNode(client_, + GetBookmarkTreeNode(managed_, managed_bookmark, false, // Recurse. false)); // Only folders. @@ -142,39 +146,39 @@ TEST_F(ExtensionBookmarksTest, GetManagedNode) { TEST_F(ExtensionBookmarksTest, RemoveNodeInvalidId) { int64 invalid_id = model_->next_node_id(); std::string error; - EXPECT_FALSE(RemoveNode(model_, client_, invalid_id, true, &error)); + EXPECT_FALSE(RemoveNode(model_, managed_, invalid_id, true, &error)); EXPECT_EQ(keys::kNoNodeError, error); } TEST_F(ExtensionBookmarksTest, RemoveNodePermanent) { std::string error; EXPECT_FALSE( - RemoveNode(model_, client_, model_->other_node()->id(), true, &error)); + RemoveNode(model_, managed_, model_->other_node()->id(), true, &error)); EXPECT_EQ(keys::kModifySpecialError, error); } TEST_F(ExtensionBookmarksTest, RemoveNodeManaged) { const BookmarkNode* managed_bookmark = - model_->AddURL(client_->managed_node(), + model_->AddURL(managed_->managed_node(), 0, base::ASCIIToUTF16("Chromium"), GURL("http://www.chromium.org")); std::string error; EXPECT_FALSE( - RemoveNode(model_, client_, managed_bookmark->id(), true, &error)); + RemoveNode(model_, managed_, managed_bookmark->id(), true, &error)); EXPECT_EQ(keys::kModifyManagedError, error); } TEST_F(ExtensionBookmarksTest, RemoveNodeNotRecursive) { std::string error; - EXPECT_FALSE(RemoveNode(model_, client_, folder_->id(), false, &error)); + EXPECT_FALSE(RemoveNode(model_, managed_, folder_->id(), false, &error)); EXPECT_EQ(keys::kFolderNotEmptyError, error); } TEST_F(ExtensionBookmarksTest, RemoveNodeRecursive) { EXPECT_EQ(3, model_->other_node()->child_count()); std::string error; - EXPECT_TRUE(RemoveNode(model_, client_, folder_->id(), true, &error)); + EXPECT_TRUE(RemoveNode(model_, managed_, folder_->id(), true, &error)); EXPECT_EQ(2, model_->other_node()->child_count()); } diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc b/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc index 7adc3d9..03674f5 100644 --- a/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc +++ b/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc @@ -5,14 +5,14 @@ #include "base/prefs/pref_service.h" #include "base/values.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/extensions/extension_apitest.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ui/browser.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_node.h" #include "components/bookmarks/common/bookmark_pref_names.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/bookmarks/test/bookmark_test_helpers.h" using bookmarks::BookmarkModel; @@ -28,8 +28,8 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_Bookmarks) { // can read them and can't modify them. Profile* profile = browser()->profile(); BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile); - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile); bookmarks::test::WaitForBookmarkModelToLoad(model); { @@ -43,7 +43,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_Bookmarks) { node->Set("children", new base::ListValue()); list.Append(node); profile->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list); - ASSERT_EQ(2, client->managed_node()->child_count()); + ASSERT_EQ(2, managed->managed_node()->child_count()); } { @@ -57,7 +57,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_Bookmarks) { node->Set("children", new base::ListValue()); list.Append(node); profile->GetPrefs()->Set(bookmarks::prefs::kSupervisedBookmarks, list); - ASSERT_EQ(2, client->supervised_node()->child_count()); + ASSERT_EQ(2, managed->supervised_node()->child_count()); } ASSERT_TRUE(RunExtensionTest("bookmarks")) << message_; diff --git a/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc b/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc index 4fe297f..3d64ad4 100644 --- a/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc +++ b/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc @@ -21,8 +21,7 @@ #include "base/time/time.h" #include "chrome/browser/bookmarks/bookmark_html_writer.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h" #include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h" #include "chrome/browser/importer/external_process_importer_host.h" @@ -38,6 +37,7 @@ #include "chrome/grit/generated_resources.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/user_prefs/user_prefs.h" #include "content/public/browser/browser_context.h" #include "content/public/browser/notification_service.h" @@ -53,6 +53,7 @@ using bookmarks::BookmarkModel; using bookmarks::BookmarkNode; +using bookmarks::ManagedBookmarkService; namespace extensions { @@ -109,8 +110,8 @@ BookmarkModel* BookmarksFunction::GetBookmarkModel() { return BookmarkModelFactory::GetForProfile(GetProfile()); } -ChromeBookmarkClient* BookmarksFunction::GetChromeBookmarkClient() { - return ChromeBookmarkClientFactory::GetForProfile(GetProfile()); +ManagedBookmarkService* BookmarksFunction::GetManagedBookmarkService() { + return ManagedBookmarkServiceFactory::GetForProfile(GetProfile()); } bool BookmarksFunction::GetBookmarkIdAsInt64(const std::string& id_string, @@ -210,9 +211,9 @@ bool BookmarksFunction::CanBeModified(const BookmarkNode* node) { error_ = keys::kModifySpecialError; return false; } - ChromeBookmarkClient* client = GetChromeBookmarkClient(); - if (::bookmarks::IsDescendantOf(node, client->managed_node()) || - ::bookmarks::IsDescendantOf(node, client->supervised_node())) { + ManagedBookmarkService* managed = GetManagedBookmarkService(); + if (::bookmarks::IsDescendantOf(node, managed->managed_node()) || + ::bookmarks::IsDescendantOf(node, managed->supervised_node())) { error_ = keys::kModifyManagedError; return false; } @@ -243,7 +244,7 @@ void BookmarksFunction::RunAndSendResponse() { BookmarkEventRouter::BookmarkEventRouter(Profile* profile) : browser_context_(profile), model_(BookmarkModelFactory::GetForProfile(profile)), - client_(ChromeBookmarkClientFactory::GetForProfile(profile)) { + managed_(ManagedBookmarkServiceFactory::GetForProfile(profile)) { model_->AddObserver(this); } @@ -296,7 +297,7 @@ void BookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model, int index) { const BookmarkNode* node = parent->GetChild(index); scoped_ptr<BookmarkTreeNode> tree_node( - bookmark_api_helpers::GetBookmarkTreeNode(client_, node, false, false)); + bookmark_api_helpers::GetBookmarkTreeNode(managed_, node, false, false)); DispatchEvent(events::BOOKMARKS_ON_CREATED, bookmarks::OnCreated::kEventName, bookmarks::OnCreated::Create(base::Int64ToString(node->id()), *tree_node)); @@ -418,7 +419,7 @@ bool BookmarksGetFunction::RunOnReady() { EXTENSION_FUNCTION_VALIDATE(params.get()); std::vector<linked_ptr<BookmarkTreeNode> > nodes; - ChromeBookmarkClient* client = GetChromeBookmarkClient(); + ManagedBookmarkService* managed = GetManagedBookmarkService(); if (params->id_or_id_list.as_strings) { std::vector<std::string>& ids = *params->id_or_id_list.as_strings; size_t count = ids.size(); @@ -427,14 +428,14 @@ bool BookmarksGetFunction::RunOnReady() { const BookmarkNode* node = GetBookmarkNodeFromId(ids[i]); if (!node) return false; - bookmark_api_helpers::AddNode(client, node, &nodes, false); + bookmark_api_helpers::AddNode(managed, node, &nodes, false); } } else { const BookmarkNode* node = GetBookmarkNodeFromId(*params->id_or_id_list.as_string); if (!node) return false; - bookmark_api_helpers::AddNode(client, node, &nodes, false); + bookmark_api_helpers::AddNode(managed, node, &nodes, false); } results_ = bookmarks::Get::Results::Create(nodes); @@ -454,8 +455,8 @@ bool BookmarksGetChildrenFunction::RunOnReady() { int child_count = node->child_count(); for (int i = 0; i < child_count; ++i) { const BookmarkNode* child = node->GetChild(i); - bookmark_api_helpers::AddNode( - GetChromeBookmarkClient(), child, &nodes, false); + bookmark_api_helpers::AddNode(GetManagedBookmarkService(), child, &nodes, + false); } results_ = bookmarks::GetChildren::Results::Create(nodes); @@ -479,8 +480,8 @@ bool BookmarksGetRecentFunction::RunOnReady() { std::vector<const BookmarkNode*>::iterator i = nodes.begin(); for (; i != nodes.end(); ++i) { const BookmarkNode* node = *i; - bookmark_api_helpers::AddNode( - GetChromeBookmarkClient(), node, &tree_nodes, false); + bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node, + &tree_nodes, false); } results_ = bookmarks::GetRecent::Results::Create(tree_nodes); @@ -491,7 +492,8 @@ bool BookmarksGetTreeFunction::RunOnReady() { std::vector<linked_ptr<BookmarkTreeNode> > nodes; const BookmarkNode* node = BookmarkModelFactory::GetForProfile(GetProfile())->root_node(); - bookmark_api_helpers::AddNode(GetChromeBookmarkClient(), node, &nodes, true); + bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node, &nodes, + true); results_ = bookmarks::GetTree::Results::Create(nodes); return true; } @@ -506,7 +508,8 @@ bool BookmarksGetSubTreeFunction::RunOnReady() { return false; std::vector<linked_ptr<BookmarkTreeNode> > nodes; - bookmark_api_helpers::AddNode(GetChromeBookmarkClient(), node, &nodes, true); + bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node, &nodes, + true); results_ = bookmarks::GetSubTree::Results::Create(nodes); return true; } @@ -551,10 +554,10 @@ bool BookmarksSearchFunction::RunOnReady() { } std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes; - ChromeBookmarkClient* client = GetChromeBookmarkClient(); + ManagedBookmarkService* managed = GetManagedBookmarkService(); for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin(); node_iter != nodes.end(); ++node_iter) { - bookmark_api_helpers::AddNode(client, *node_iter, &tree_nodes, false); + bookmark_api_helpers::AddNode(managed, *node_iter, &tree_nodes, false); } results_ = bookmarks::Search::Results::Create(tree_nodes); @@ -593,8 +596,8 @@ bool BookmarksRemoveFunction::RunOnReady() { recursive = true; BookmarkModel* model = GetBookmarkModel(); - ChromeBookmarkClient* client = GetChromeBookmarkClient(); - if (!bookmark_api_helpers::RemoveNode(model, client, id, recursive, &error_)) + ManagedBookmarkService* managed = GetManagedBookmarkService(); + if (!bookmark_api_helpers::RemoveNode(model, managed, id, recursive, &error_)) return false; return true; @@ -614,7 +617,7 @@ bool BookmarksCreateFunction::RunOnReady() { return false; scoped_ptr<BookmarkTreeNode> ret(bookmark_api_helpers::GetBookmarkTreeNode( - GetChromeBookmarkClient(), node, false, false)); + GetManagedBookmarkService(), node, false, false)); results_ = bookmarks::Create::Results::Create(*ret); return true; @@ -674,8 +677,8 @@ bool BookmarksMoveFunction::RunOnReady() { model->Move(node, parent, index); scoped_ptr<BookmarkTreeNode> tree_node( - bookmark_api_helpers::GetBookmarkTreeNode( - GetChromeBookmarkClient(), node, false, false)); + bookmark_api_helpers::GetBookmarkTreeNode(GetManagedBookmarkService(), + node, false, false)); results_ = bookmarks::Move::Results::Create(*tree_node); return true; @@ -730,8 +733,8 @@ bool BookmarksUpdateFunction::RunOnReady() { model->SetURL(node, url); scoped_ptr<BookmarkTreeNode> tree_node( - bookmark_api_helpers::GetBookmarkTreeNode( - GetChromeBookmarkClient(), node, false, false)); + bookmark_api_helpers::GetBookmarkTreeNode(GetManagedBookmarkService(), + node, false, false)); results_ = bookmarks::Update::Results::Create(*tree_node); return true; } diff --git a/chrome/browser/extensions/api/bookmarks/bookmarks_api.h b/chrome/browser/extensions/api/bookmarks/bookmarks_api.h index 2ea2857..f25e7ea 100644 --- a/chrome/browser/extensions/api/bookmarks/bookmarks_api.h +++ b/chrome/browser/extensions/api/bookmarks/bookmarks_api.h @@ -18,13 +18,16 @@ #include "extensions/browser/event_router.h" #include "ui/shell_dialogs/select_file_dialog.h" -class ChromeBookmarkClient; - namespace base { class FilePath; class ListValue; } +namespace bookmarks { +class BookmarkModel; +class ManagedBookmarkService; +} + namespace content { class BrowserContext; } @@ -82,7 +85,7 @@ class BookmarkEventRouter : public bookmarks::BookmarkModelObserver { content::BrowserContext* browser_context_; bookmarks::BookmarkModel* model_; - ChromeBookmarkClient* client_; + bookmarks::ManagedBookmarkService* managed_; DISALLOW_COPY_AND_ASSIGN(BookmarkEventRouter); }; @@ -132,8 +135,8 @@ class BookmarksFunction : public ChromeAsyncExtensionFunction, // Helper to get the BookmarkModel. bookmarks::BookmarkModel* GetBookmarkModel(); - // Helper to get the ChromeBookmarkClient. - ChromeBookmarkClient* GetChromeBookmarkClient(); + // Helper to get the ManagedBookmarkService. + bookmarks::ManagedBookmarkService* GetManagedBookmarkService(); // Helper to get the bookmark id as int64 from the given string id. // Sets error_ to an error string if the given id string can't be parsed diff --git a/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc b/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc index c13d4e2..445e482 100644 --- a/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc +++ b/chrome/browser/sync/glue/bookmark_data_type_controller_unittest.cc @@ -14,6 +14,7 @@ #include "chrome/browser/bookmarks/bookmark_model_factory.h" #include "chrome/browser/bookmarks/chrome_bookmark_client.h" #include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/history/history_service_factory.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/sync/profile_sync_components_factory_mock.h" @@ -55,12 +56,6 @@ class HistoryMock : public history::HistoryService { ~HistoryMock() override {} }; -scoped_ptr<KeyedService> BuildChromeBookmarkClient( - content::BrowserContext* context) { - return make_scoped_ptr( - new ChromeBookmarkClient(static_cast<Profile*>(context))); -} - scoped_ptr<KeyedService> BuildBookmarkModelWithoutLoading( content::BrowserContext* context) { Profile* profile = static_cast<Profile*>(context); @@ -114,8 +109,10 @@ class SyncBookmarkDataTypeControllerTest : public testing::Test { }; void CreateBookmarkModel(BookmarkLoadPolicy bookmark_load_policy) { + ManagedBookmarkServiceFactory::GetInstance()->SetTestingFactory( + &profile_, ManagedBookmarkServiceFactory::GetDefaultFactory()); ChromeBookmarkClientFactory::GetInstance()->SetTestingFactory( - &profile_, BuildChromeBookmarkClient); + &profile_, ChromeBookmarkClientFactory::GetDefaultFactory()); if (bookmark_load_policy == LOAD_MODEL) { bookmark_model_ = static_cast<BookmarkModel*>( BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse( diff --git a/chrome/browser/sync/test/integration/bookmarks_helper.cc b/chrome/browser/sync/test/integration/bookmarks_helper.cc index 08a863e..8526cac 100644 --- a/chrome/browser/sync/test/integration/bookmarks_helper.cc +++ b/chrome/browser/sync/test/integration/bookmarks_helper.cc @@ -20,8 +20,7 @@ #include "base/synchronization/waitable_event.h" #include "base/task/cancelable_task_tracker.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/favicon/favicon_service_factory.h" #include "chrome/browser/history/history_service_factory.h" #include "chrome/browser/profiles/profile.h" @@ -37,6 +36,7 @@ #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_model_observer.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/favicon/core/favicon_service.h" #include "components/favicon_base/favicon_util.h" #include "components/history/core/browser/history_db_task.h" @@ -464,8 +464,9 @@ const BookmarkNode* GetSyncedBookmarksNode(int index) { } const BookmarkNode* GetManagedNode(int index) { - return ChromeBookmarkClientFactory::GetForProfile( - sync_datatype_helper::test()->GetProfile(index))->managed_node(); + return ManagedBookmarkServiceFactory::GetForProfile( + sync_datatype_helper::test()->GetProfile(index)) + ->managed_node(); } BookmarkModel* GetVerifierBookmarkModel() { diff --git a/chrome/browser/ui/bookmarks/bookmark_context_menu_controller.cc b/chrome/browser/ui/bookmarks/bookmark_context_menu_controller.cc index 92ab0fa..7bc0256 100644 --- a/chrome/browser/ui/bookmarks/bookmark_context_menu_controller.cc +++ b/chrome/browser/ui/bookmarks/bookmark_context_menu_controller.cc @@ -9,8 +9,7 @@ #include "base/prefs/pref_service.h" #include "chrome/app/chrome_command_ids.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/prefs/incognito_mode_prefs.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ui/bookmarks/bookmark_editor.h" @@ -25,6 +24,7 @@ #include "components/bookmarks/browser/bookmark_client.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/undo/bookmark_undo_service.h" #include "content/public/browser/page_navigator.h" #include "content/public/browser/user_metrics.h" @@ -320,10 +320,10 @@ base::string16 BookmarkContextMenuController::GetLabelForCommandId( undo_manager()->GetRedoLabel(); } if (command_id == IDC_BOOKMARK_BAR_SHOW_MANAGED_BOOKMARKS) { - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); return l10n_util::GetStringFUTF16(IDS_BOOKMARK_BAR_SHOW_MANAGED_BOOKMARKS, - client->managed_node()->GetTitle()); + managed->managed_node()->GetTitle()); } NOTREACHED(); @@ -417,9 +417,9 @@ bool BookmarkContextMenuController::IsCommandIdVisible(int command_id) const { if (command_id == IDC_BOOKMARK_BAR_SHOW_MANAGED_BOOKMARKS) { // The option to hide the Managed Bookmarks folder is only available if // there are any managed bookmarks configured at all. - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); - return !client->managed_node()->empty(); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); + return !managed->managed_node()->empty(); } return true; diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h index 3a25435..88ee285 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h @@ -27,7 +27,6 @@ @class BookmarkFolderTarget; @class BookmarkContextMenuCocoaController; class Browser; -class ChromeBookmarkClient; class GURL; namespace ui { class ThemeProvider; @@ -37,6 +36,7 @@ namespace bookmarks { class BookmarkModel; class BookmarkNode; +class ManagedBookmarkService; // Magic numbers from Cole // TODO(jrg): create an objc-friendly version of bookmark_bar_constants.h? @@ -175,7 +175,7 @@ willAnimateFromState:(BookmarkBar::State)oldState Browser* browser_; // weak; owned by its window bookmarks::BookmarkModel* bookmarkModel_; // weak; part of the profile owned // by the top-level Browser object. - ChromeBookmarkClient* bookmarkClient_; + bookmarks::ManagedBookmarkService* managedBookmarkService_; // Our initial view width, which is applied in awakeFromNib. CGFloat initialWidth_; diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.mm index 82e3146..c540d72 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.mm +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.mm @@ -10,8 +10,7 @@ #include "base/strings/sys_string_conversions.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" #include "chrome/browser/bookmarks/bookmark_stats.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/prefs/incognito_mode_prefs.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/themes/theme_properties.h" @@ -51,6 +50,7 @@ #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_node_data.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "content/public/browser/user_metrics.h" #include "content/public/browser/web_contents.h" #include "extensions/browser/extension_registry.h" @@ -259,8 +259,8 @@ void RecordAppLaunch(Profile* profile, GURL url) { browser_ = browser; initialWidth_ = initialWidth; bookmarkModel_ = BookmarkModelFactory::GetForProfile(browser_->profile()); - bookmarkClient_ = - ChromeBookmarkClientFactory::GetForProfile(browser_->profile()); + managedBookmarkService_ = + ManagedBookmarkServiceFactory::GetForProfile(browser_->profile()); buttons_.reset([[NSMutableArray alloc] init]); delegate_ = delegate; resizeDelegate_ = resizeDelegate; @@ -600,13 +600,13 @@ void RecordAppLaunch(Profile* profile, GURL url) { if (!node) return defaultImage_; - if (node == bookmarkClient_->managed_node()) { + if (node == managedBookmarkService_->managed_node()) { // Most users never see this node, so the image is only loaded if needed. ResourceBundle& rb = ResourceBundle::GetSharedInstance(); return rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_FOLDER_MANAGED).ToNSImage(); } - if (node == bookmarkClient_->supervised_node()) { + if (node == managedBookmarkService_->supervised_node()) { // Most users never see this node, so the image is only loaded if needed. ResourceBundle& rb = ResourceBundle::GetSharedInstance(); return rb.GetNativeImageNamed( @@ -636,7 +636,7 @@ void RecordAppLaunch(Profile* profile, GURL url) { - (BOOL)canEditBookmark:(const BookmarkNode*)node { // Don't allow edit/delete of the permanent nodes. if (node == nil || bookmarkModel_->is_permanent_node(node) || - !bookmarkClient_->CanBeEditedByUser(node)) { + !managedBookmarkService_->CanBeEditedByUser(node)) { return NO; } return YES; @@ -1297,7 +1297,7 @@ void RecordAppLaunch(Profile* profile, GURL url) { if (managedBookmarksButton_.get()) { // The node's title might have changed if the user signed in or out. // Make sure it's up to date now. - const BookmarkNode* node = bookmarkClient_->managed_node(); + const BookmarkNode* node = managedBookmarkService_->managed_node(); NSString* title = base::SysUTF16ToNSString(node->GetTitle()); NSCell* cell = [managedBookmarksButton_ cell]; [cell setTitle:title]; @@ -1308,7 +1308,8 @@ void RecordAppLaunch(Profile* profile, GURL url) { return; } - NSCell* cell = [self cellForBookmarkNode:bookmarkClient_->managed_node()]; + NSCell* cell = + [self cellForBookmarkNode:managedBookmarkService_->managed_node()]; managedBookmarksButton_.reset([self createCustomBookmarkButtonForCell:cell]); [managedBookmarksButton_ setAction:@selector(openBookmarkFolderFromButton:)]; view_id_util::SetID(managedBookmarksButton_.get(), VIEW_ID_MANAGED_BOOKMARKS); @@ -1325,7 +1326,8 @@ void RecordAppLaunch(Profile* profile, GURL url) { return; } - NSCell* cell = [self cellForBookmarkNode:bookmarkClient_->supervised_node()]; + NSCell* cell = + [self cellForBookmarkNode:managedBookmarkService_->supervised_node()]; supervisedBookmarksButton_.reset( [self createCustomBookmarkButtonForCell:cell]); [supervisedBookmarksButton_ @@ -2089,9 +2091,9 @@ static BOOL ValueInRangeInclusive(CGFloat low, CGFloat value, CGFloat high) { destIndex = [self indexForDragToPoint:point]; } - if (!bookmarkClient_->CanBeEditedByUser(destParent)) + if (!managedBookmarkService_->CanBeEditedByUser(destParent)) return NO; - if (!bookmarkClient_->CanBeEditedByUser(sourceNode)) + if (!managedBookmarkService_->CanBeEditedByUser(sourceNode)) copy = YES; // Be sure we don't try and drop a folder into itself. @@ -2808,7 +2810,7 @@ static BOOL ValueInRangeInclusive(CGFloat low, CGFloat value, CGFloat high) { destIndex = [self indexForDragToPoint:point]; } - if (!bookmarkClient_->CanBeEditedByUser(destParent)) + if (!managedBookmarkService_->CanBeEditedByUser(destParent)) return NO; // Don't add the bookmarks if the destination index shows an error. diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller.mm index 2626bb1..6b49f00 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller.mm +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller.mm @@ -7,8 +7,7 @@ #include "base/mac/bundle_locations.h" #include "base/strings/sys_string_conversions.h" #import "chrome/browser/bookmarks/bookmark_model_factory.h" -#import "chrome/browser/bookmarks/chrome_bookmark_client.h" -#import "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#import "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #import "chrome/browser/profiles/profile.h" #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_constants.h" #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h" @@ -21,6 +20,7 @@ #import "chrome/browser/ui/cocoa/browser_window_controller.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_node_data.h" +#import "components/bookmarks/managed/managed_bookmark_service.h" #include "ui/base/theme_provider.h" using bookmarks::BookmarkModel; @@ -1280,11 +1280,11 @@ static BOOL ValueInRangeInclusive(CGFloat low, CGFloat value, CGFloat high) { destIndex += [[parentButton_ cell] startingChildIndex]; } - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); - if (!client->CanBeEditedByUser(destParent)) + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); + if (!managed->CanBeEditedByUser(destParent)) return NO; - if (!client->CanBeEditedByUser(sourceNode)) + if (!managed->CanBeEditedByUser(sourceNode)) copy = YES; // Prevent cycles. @@ -1852,9 +1852,9 @@ static BOOL ValueInRangeInclusive(CGFloat low, CGFloat value, CGFloat high) { destIndex += [[parentButton_ cell] startingChildIndex]; } - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); - if (!client->CanBeEditedByUser(destParent)) + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); + if (!managed->CanBeEditedByUser(destParent)) return NO; // Create and add the new bookmark nodes. diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h b/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h index 708ae71..1650def 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h @@ -9,13 +9,13 @@ #import "chrome/browser/ui/cocoa/base_bubble_controller.h" #import "chrome/browser/ui/cocoa/bookmarks/bookmark_model_observer_for_cocoa.h" -class ChromeBookmarkClient; @class BookmarkBubbleController; @class BookmarkSyncPromoController; namespace bookmarks { class BookmarkModel; class BookmarkNode; +class ManagedBookmarkService; } // Controller for the bookmark bubble. The bookmark bubble is a @@ -24,9 +24,9 @@ class BookmarkNode; // the bookmark in various ways (name, folder, etc.) @interface BookmarkBubbleController : BaseBubbleController { @private - // |client_|, |model_| and |node_| are weak and owned by the current browser's - // profile. - ChromeBookmarkClient* client_; // weak + // |managed_|, |model_| and |node_| are weak and owned by the current + // browser's profile. + bookmarks::ManagedBookmarkService* managedBookmarkService_; // weak bookmarks::BookmarkModel* model_; // weak const bookmarks::BookmarkNode* node_; // weak @@ -56,7 +56,7 @@ class BookmarkNode; // it desires it to be visible on the screen. It is not shown by the // init routine. Closing of the window happens implicitly on dealloc. - (id)initWithParentWindow:(NSWindow*)parentWindow - client:(ChromeBookmarkClient*)client + managed:(bookmarks::ManagedBookmarkService*)managed model:(bookmarks::BookmarkModel*)model node:(const bookmarks::BookmarkNode*)node alreadyBookmarked:(BOOL)alreadyBookmarked; diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.mm index 59999b1..2fed9b9 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.mm +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.mm @@ -6,7 +6,6 @@ #include "base/mac/bundle_locations.h" #include "base/strings/sys_string_conversions.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" #include "chrome/browser/ui/browser.h" #include "chrome/browser/ui/browser_finder.h" #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button.h" @@ -17,6 +16,7 @@ #include "chrome/grit/generated_resources.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "content/public/browser/notification_observer.h" #include "content/public/browser/notification_registrar.h" #include "content/public/browser/notification_service.h" @@ -54,16 +54,16 @@ using bookmarks::BookmarkNode; } - (id)initWithParentWindow:(NSWindow*)parentWindow - client:(ChromeBookmarkClient*)client + managed:(bookmarks::ManagedBookmarkService*)managed model:(BookmarkModel*)model node:(const BookmarkNode*)node alreadyBookmarked:(BOOL)alreadyBookmarked { - DCHECK(client); + DCHECK(managed); DCHECK(node); if ((self = [super initWithWindowNibPath:@"BookmarkBubble" parentWindow:parentWindow anchoredAt:NSZeroPoint])) { - client_ = client; + managedBookmarkService_ = managed; model_ = model; node_ = node; alreadyBookmarked_ = alreadyBookmarked; @@ -107,8 +107,9 @@ using bookmarks::BookmarkNode; - (void)startPulsingBookmarkButton:(const BookmarkNode*)node { while (node) { if ((node->parent() == model_->bookmark_bar_node()) || - (node->parent() == client_->managed_node()) || - (node->parent() == client_->supervised_node()) || + (node->parent() == + managedBookmarkService_->managed_node()) || + (node->parent() == managedBookmarkService_->supervised_node()) || (node == model_->other_node())) { pulsingBookmarkNode_ = node; bookmarkObserver_->StartObservingNode(pulsingBookmarkNode_); @@ -380,7 +381,7 @@ using bookmarks::BookmarkNode; for (int i = 0; i < parent->child_count(); i++) { const BookmarkNode* child = parent->GetChild(i); if (child->is_folder() && child->IsVisible() && - client_->CanBeEditedByUser(child)) { + managedBookmarkService_->CanBeEditedByUser(child)) { [self addFolderNodes:child toPopUpButton:button indentation:indentation]; diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller_unittest.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller_unittest.mm index d979bbe..758835a 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller_unittest.mm +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller_unittest.mm @@ -9,8 +9,7 @@ #include "base/strings/string16.h" #include "base/strings/utf_string_conversions.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/signin/signin_manager_factory.h" #include "chrome/browser/ui/browser.h" #include "chrome/browser/ui/browser_window.h" @@ -20,6 +19,7 @@ #import "chrome/browser/ui/cocoa/info_bubble_window.h" #include "chrome/test/base/testing_profile.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/signin/core/browser/signin_manager.h" #include "content/public/browser/notification_service.h" #include "testing/gtest/include/gtest/gtest.h" @@ -93,11 +93,11 @@ class BookmarkBubbleControllerTest : public CocoaProfileTest { controller_ = nil; } BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile()); - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile()); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile()); controller_ = [[BookmarkBubbleController alloc] initWithParentWindow:browser()->window()->GetNativeWindow() - client:client + managed:managed model:model node:node alreadyBookmarked:YES]; @@ -396,12 +396,12 @@ TEST_F(BookmarkBubbleControllerTest, PopUpSelectionChanged) { // them pressing escape. The bookmark should not be there. TEST_F(BookmarkBubbleControllerTest, EscapeRemovesNewBookmark) { BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile()); - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile()); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile()); const BookmarkNode* node = CreateTestBookmark(); BookmarkBubbleController* controller = [[BookmarkBubbleController alloc] initWithParentWindow:browser()->window()->GetNativeWindow() - client:client + managed:managed model:model node:node alreadyBookmarked:NO]; // The last param is the key difference. diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm index 4034a8b..3dd838c 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_editor_base_controller.mm @@ -11,8 +11,7 @@ #include "base/mac/bundle_locations.h" #include "base/strings/sys_string_conversions.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/profiles/profile.h" #import "chrome/browser/ui/cocoa/bookmarks/bookmark_all_tabs_controller.h" #import "chrome/browser/ui/cocoa/bookmarks/bookmark_editor_controller.h" @@ -21,6 +20,7 @@ #import "chrome/browser/ui/cocoa/browser_window_controller.h" #include "chrome/grit/generated_resources.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "ui/base/l10n/l10n_util.h" #include "ui/base/l10n/l10n_util_mac.h" @@ -505,14 +505,14 @@ NSString* const kOkEnabledName = @"okEnabled"; } - (NSMutableArray*)addChildFoldersFromNode:(const BookmarkNode*)node { - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); NSMutableArray* childFolders = nil; int childCount = node->child_count(); for (int i = 0; i < childCount; ++i) { const BookmarkNode* childNode = node->GetChild(i); if (childNode->is_folder() && childNode->IsVisible() && - client->CanBeEditedByUser(childNode)) { + managed->CanBeEditedByUser(childNode)) { NSString* childName = base::SysUTF16ToNSString(childNode->GetTitle()); NSMutableArray* children = [self addChildFoldersFromNode:childNode]; BookmarkFolderInfo* folderInfo = diff --git a/chrome/browser/ui/cocoa/bookmarks/bookmark_menu_bridge.mm b/chrome/browser/ui/cocoa/bookmarks/bookmark_menu_bridge.mm index ef81068..74fc155 100644 --- a/chrome/browser/ui/cocoa/bookmarks/bookmark_menu_bridge.mm +++ b/chrome/browser/ui/cocoa/bookmarks/bookmark_menu_bridge.mm @@ -8,8 +8,7 @@ #include "chrome/app/chrome_command_ids.h" #import "chrome/browser/app_controller_mac.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/prefs/incognito_mode_prefs.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/profiles/profile_manager.h" @@ -18,6 +17,7 @@ #import "chrome/browser/ui/cocoa/bookmarks/bookmark_menu_cocoa_controller.h" #include "chrome/grit/generated_resources.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "grit/theme_resources.h" #include "ui/base/l10n/l10n_util.h" #include "ui/base/resource/resource_bundle.h" @@ -76,11 +76,11 @@ void BookmarkMenuBridge::UpdateMenuInternal(NSMenu* bookmark_menu, // Add at most one separator for the bookmark bar and the managed and // supervised bookmarks folders. - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(profile_); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_); const BookmarkNode* barNode = model->bookmark_bar_node(); - const BookmarkNode* managedNode = client->managed_node(); - const BookmarkNode* supervisedNode = client->supervised_node(); + const BookmarkNode* managedNode = managed->managed_node(); + const BookmarkNode* supervisedNode = managed->supervised_node(); if (!barNode->empty() || !managedNode->empty() || !supervisedNode->empty()) [bookmark_menu addItem:[NSMenuItem separatorItem]]; if (!managedNode->empty()) { diff --git a/chrome/browser/ui/cocoa/browser_window_controller.mm b/chrome/browser/ui/cocoa/browser_window_controller.mm index a3a39bd..e657c77 100644 --- a/chrome/browser/ui/cocoa/browser_window_controller.mm +++ b/chrome/browser/ui/cocoa/browser_window_controller.mm @@ -17,8 +17,7 @@ #include "chrome/app/chrome_command_ids.h" // IDC_* #import "chrome/browser/app_controller_mac.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/devtools/devtools_window.h" #include "chrome/browser/extensions/extension_commands_global_registry.h" @@ -84,6 +83,7 @@ #include "chrome/grit/generated_resources.h" #include "chrome/grit/locale_settings.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/signin/core/common/profile_management_switches.h" #include "components/translate/core/browser/translate_manager.h" #include "components/translate/core/browser/translate_ui_delegate.h" @@ -1775,12 +1775,12 @@ using content::WebContents; if (!bookmarkBubbleController_) { BookmarkModel* model = BookmarkModelFactory::GetForProfile(browser_->profile()); - ChromeBookmarkClient* client = - ChromeBookmarkClientFactory::GetForProfile(browser_->profile()); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(browser_->profile()); const BookmarkNode* node = model->GetMostRecentlyAddedUserNodeForURL(url); bookmarkBubbleController_ = [[BookmarkBubbleController alloc] initWithParentWindow:[self window] - client:client + managed:managed model:model node:node alreadyBookmarked:alreadyMarked]; diff --git a/chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc b/chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc index 771df71..450d448 100644 --- a/chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc +++ b/chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc @@ -19,8 +19,7 @@ #include "base/strings/utf_string_conversions.h" #include "base/thread_task_runner_handle.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/chrome_notification_types.h" #include "chrome/browser/defaults.h" @@ -55,6 +54,7 @@ #include "chrome/grit/generated_resources.h" #include "components/bookmarks/browser/bookmark_model.h" #include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/metrics/metrics_service.h" #include "content/public/browser/notification_details.h" #include "content/public/browser/notification_source.h" @@ -503,7 +503,7 @@ const char BookmarkBarView::kViewClassName[] = "BookmarkBarView"; BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view) : page_navigator_(NULL), - client_(NULL), + managed_(NULL), bookmark_menu_(NULL), bookmark_drop_menu_(NULL), other_bookmarks_button_(NULL), @@ -607,13 +607,13 @@ const BookmarkNode* BookmarkBarView::GetNodeForButtonAtModelIndex( // Check the managed button first. if (managed_bookmarks_button_->visible() && managed_bookmarks_button_->bounds().Contains(adjusted_loc)) { - return client_->managed_node(); + return managed_->managed_node(); } // Then check the supervised button. if (supervised_bookmarks_button_->visible() && supervised_bookmarks_button_->bounds().Contains(adjusted_loc)) { - return client_->supervised_node(); + return managed_->supervised_node(); } // Then check the bookmark buttons. @@ -643,9 +643,9 @@ const BookmarkNode* BookmarkBarView::GetNodeForButtonAtModelIndex( views::MenuButton* BookmarkBarView::GetMenuButtonForNode( const BookmarkNode* node) { - if (node == client_->managed_node()) + if (node == managed_->managed_node()) return managed_bookmarks_button_; - if (node == client_->supervised_node()) + if (node == managed_->supervised_node()) return supervised_bookmarks_button_; if (node == model_->other_node()) return other_bookmarks_button_; @@ -1234,11 +1234,12 @@ void BookmarkBarView::BookmarkModelLoaded(BookmarkModel* model, other_bookmarks_button_->SetAccessibleName(model->other_node()->GetTitle()); other_bookmarks_button_->SetText(model->other_node()->GetTitle()); managed_bookmarks_button_->SetAccessibleName( - client_->managed_node()->GetTitle()); - managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle()); + managed_->managed_node()->GetTitle()); + managed_bookmarks_button_->SetText(managed_->managed_node()->GetTitle()); supervised_bookmarks_button_->SetAccessibleName( - client_->supervised_node()->GetTitle()); - supervised_bookmarks_button_->SetText(client_->supervised_node()->GetTitle()); + managed_->supervised_node()->GetTitle()); + supervised_bookmarks_button_->SetText( + managed_->supervised_node()->GetTitle()); UpdateColors(); UpdateOtherAndManagedButtonsVisibility(); other_bookmarks_button_->SetEnabled(true); @@ -1417,9 +1418,9 @@ void BookmarkBarView::OnMenuButtonClicked(views::View* view, if (view == other_bookmarks_button_) { node = model_->other_node(); } else if (view == managed_bookmarks_button_) { - node = client_->managed_node(); + node = managed_->managed_node(); } else if (view == supervised_bookmarks_button_) { - node = client_->supervised_node(); + node = managed_->supervised_node(); } else if (view == overflow_button_) { node = model_->bookmark_bar_node(); start_index = GetFirstHiddenNodeIndex(); @@ -1456,9 +1457,9 @@ void BookmarkBarView::ButtonPressed(views::Button* sender, if (sender->tag() == kOtherFolderButtonTag) { node = model_->other_node(); } else if (sender->tag() == kManagedFolderButtonTag) { - node = client_->managed_node(); + node = managed_->managed_node(); } else if (sender->tag() == kSupervisedFolderButtonTag) { - node = client_->supervised_node(); + node = managed_->supervised_node(); } else { int index = GetIndexOf(sender); DCHECK_NE(-1, index); @@ -1496,10 +1497,10 @@ void BookmarkBarView::ShowContextMenuForView(views::View* source, // sure the user can't edit/delete the node in this case. nodes.push_back(parent); } else if (source == managed_bookmarks_button_) { - parent = client_->managed_node(); + parent = managed_->managed_node(); nodes.push_back(parent); } else if (source == supervised_bookmarks_button_) { - parent = client_->supervised_node(); + parent = managed_->supervised_node(); nodes.push_back(parent); } else if (source != this && source != apps_page_shortcut_) { // User clicked on one of the bookmark buttons, find which one they @@ -1579,7 +1580,7 @@ void BookmarkBarView::Init() { size_animation_.reset(new gfx::SlideAnimation(this)); model_ = BookmarkModelFactory::GetForProfile(browser_->profile()); - client_ = ChromeBookmarkClientFactory::GetForProfile(browser_->profile()); + managed_ = ManagedBookmarkServiceFactory::GetForProfile(browser_->profile()); if (model_) { model_->AddObserver(this); if (model_->loaded()) @@ -1765,19 +1766,19 @@ bool BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model, void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model, const BookmarkNode* node) { - if (node == client_->managed_node()) { + if (node == managed_->managed_node()) { // The managed node may have its title updated. managed_bookmarks_button_->SetAccessibleName( - client_->managed_node()->GetTitle()); - managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle()); + managed_->managed_node()->GetTitle()); + managed_bookmarks_button_->SetText(managed_->managed_node()->GetTitle()); return; } - if (node == client_->supervised_node()) { + if (node == managed_->supervised_node()) { // The supervised node may have its title updated. supervised_bookmarks_button_->SetAccessibleName( - client_->supervised_node()->GetTitle()); + managed_->supervised_node()->GetTitle()); supervised_bookmarks_button_->SetText( - client_->supervised_node()->GetTitle()); + managed_->supervised_node()->GetTitle()); return; } @@ -1867,7 +1868,7 @@ void BookmarkBarView::CalculateDropLocation(const DropTargetEvent& event, // No bookmarks, accept the drop. location->index = 0; const BookmarkNode* node = data.GetFirstNode(model_, profile->GetPath()); - int ops = node && client_->CanBeEditedByUser(node) ? + int ops = node && managed_->CanBeEditedByUser(node) ? ui::DragDropTypes::DRAG_MOVE : ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK; location->operation = chrome::GetPreferredBookmarkDropOperation( @@ -1973,9 +1974,9 @@ void BookmarkBarView::StartThrobbing(const BookmarkNode* node, } else if (!overflow_only) { throbbing_view_ = static_cast<CustomButton*>(child_at(index)); } - } else if (bookmarks::IsDescendantOf(node, client_->managed_node())) { + } else if (bookmarks::IsDescendantOf(node, managed_->managed_node())) { throbbing_view_ = managed_bookmarks_button_; - } else if (bookmarks::IsDescendantOf(node, client_->supervised_node())) { + } else if (bookmarks::IsDescendantOf(node, managed_->supervised_node())) { throbbing_view_ = supervised_bookmarks_button_; } else if (!overflow_only) { throbbing_view_ = other_bookmarks_button_; @@ -2007,9 +2008,9 @@ views::CustomButton* BookmarkBarView::DetermineViewToThrobFromRemove( } return static_cast<CustomButton*>(child_at(old_index_on_bb)); } - if (bookmarks::IsDescendantOf(parent, client_->managed_node())) + if (bookmarks::IsDescendantOf(parent, managed_->managed_node())) return managed_bookmarks_button_; - if (bookmarks::IsDescendantOf(parent, client_->supervised_node())) + if (bookmarks::IsDescendantOf(parent, managed_->supervised_node())) return supervised_bookmarks_button_; // Node wasn't on the bookmark bar, use the "Other Bookmarks" button. return other_bookmarks_button_; @@ -2040,14 +2041,14 @@ bool BookmarkBarView::UpdateOtherAndManagedButtonsVisibility() { UpdateBookmarksSeparatorVisibility(); } - bool show_managed = !client_->managed_node()->empty() && + bool show_managed = !managed_->managed_node()->empty() && browser_->profile()->GetPrefs()->GetBoolean( bookmarks::prefs::kShowManagedBookmarksInBookmarkBar); bool update_managed = show_managed != managed_bookmarks_button_->visible(); if (update_managed) managed_bookmarks_button_->SetVisible(show_managed); - bool show_supervised = !client_->supervised_node()->empty(); + bool show_supervised = !managed_->supervised_node()->empty(); bool update_supervised = show_supervised != supervised_bookmarks_button_->visible(); if (update_supervised) diff --git a/chrome/browser/ui/views/bookmarks/bookmark_bar_view.h b/chrome/browser/ui/views/bookmarks/bookmark_bar_view.h index 644e12f..b5dd2b1 100644 --- a/chrome/browser/ui/views/bookmarks/bookmark_bar_view.h +++ b/chrome/browser/ui/views/bookmarks/bookmark_bar_view.h @@ -33,11 +33,11 @@ class BookmarkBarViewTestHelper; class BookmarkContextMenu; class Browser; class BrowserView; -class ChromeBookmarkClient; class Profile; namespace bookmarks { class BookmarkModel; +class ManagedBookmarkService; } namespace content { @@ -402,8 +402,8 @@ class BookmarkBarView : public views::AccessiblePaneView, // view. This is owned by the Profile. bookmarks::BookmarkModel* model_; - // ChromeBookmarkClient. This is owned by the Profile. - ChromeBookmarkClient* client_; + // ManagedBookmarkService. This is owned by the Profile. + bookmarks::ManagedBookmarkService* managed_; // Used to manage showing a Menu, either for the most recently bookmarked // entries, or for the starred folder. diff --git a/chrome/browser/ui/views/bookmarks/bookmark_context_menu_unittest.cc b/chrome/browser/ui/views/bookmarks/bookmark_context_menu_unittest.cc index a65489f..1608880 100644 --- a/chrome/browser/ui/views/bookmarks/bookmark_context_menu_unittest.cc +++ b/chrome/browser/ui/views/bookmarks/bookmark_context_menu_unittest.cc @@ -15,13 +15,13 @@ #include "base/values.h" #include "chrome/app/chrome_command_ids.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ui/bookmarks/bookmark_utils.h" #include "chrome/common/pref_names.h" #include "chrome/test/base/testing_profile.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "components/bookmarks/test/bookmark_test_helpers.h" #include "content/public/browser/page_navigator.h" #include "content/public/test/test_browser_thread.h" @@ -349,9 +349,9 @@ TEST_F(BookmarkContextMenuTest, ShowManagedBookmarks) { NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes, false)); // Verify that there are no managed nodes yet. - ChromeBookmarkClient* client = ChromeBookmarkClientFactory::GetForProfile( - profile_.get()); - EXPECT_TRUE(client->managed_node()->empty()); + bookmarks::ManagedBookmarkService* managed = + ManagedBookmarkServiceFactory::GetForProfile(profile_.get()); + EXPECT_TRUE(managed->managed_node()->empty()); // The context menu should not show the option to "Show managed bookmarks". EXPECT_FALSE( @@ -370,9 +370,9 @@ TEST_F(BookmarkContextMenuTest, ShowManagedBookmarks) { dict->SetString("url", "http://google.com"); base::ListValue list; list.Append(dict); - EXPECT_TRUE(client->managed_node()->empty()); + EXPECT_TRUE(managed->managed_node()->empty()); profile_->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list); - EXPECT_FALSE(client->managed_node()->empty()); + EXPECT_FALSE(managed->managed_node()->empty()); // New context menus now show the "Show managed bookmarks" option. controller.reset(new BookmarkContextMenu( diff --git a/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.cc b/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.cc index ec43608..b5d6d7c 100644 --- a/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.cc +++ b/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.cc @@ -8,8 +8,7 @@ #include "base/strings/utf_string_conversions.h" #include "chrome/app/chrome_command_ids.h" #include "chrome/browser/bookmarks/bookmark_model_factory.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client.h" -#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ui/bookmarks/bookmark_drag_drop.h" #include "chrome/browser/ui/bookmarks/bookmark_utils.h" @@ -18,6 +17,7 @@ #include "chrome/browser/ui/views/event_utils.h" #include "chrome/common/pref_names.h" #include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/managed/managed_bookmark_service.h" #include "content/public/browser/page_navigator.h" #include "content/public/browser/user_metrics.h" #include "grit/theme_resources.h" @@ -76,12 +76,13 @@ void BookmarkMenuDelegate::Init(views::MenuDelegate* real_delegate, // current node has children. If |node| is the bookmark bar then the // managed node is shown as its first child, if it's not empty. BookmarkModel* model = GetBookmarkModel(); - ChromeBookmarkClient* client = GetChromeBookmarkClient(); + bookmarks::ManagedBookmarkService* managed = GetManagedBookmarkService(); bool show_forced_folders = show_options == SHOW_PERMANENT_FOLDERS && node == model->bookmark_bar_node(); - bool show_managed = show_forced_folders && !client->managed_node()->empty(); + bool show_managed = + show_forced_folders && !managed->managed_node()->empty(); bool show_supervised = - show_forced_folders && !client->supervised_node()->empty(); + show_forced_folders && !managed->supervised_node()->empty(); bool has_children = (start_child_index < node->child_count()) || show_managed || show_supervised; int initial_count = parent->GetSubmenu() ? @@ -110,8 +111,9 @@ BookmarkModel* BookmarkMenuDelegate::GetBookmarkModel() { return BookmarkModelFactory::GetForProfile(profile_); } -ChromeBookmarkClient* BookmarkMenuDelegate::GetChromeBookmarkClient() { - return ChromeBookmarkClientFactory::GetForProfile(profile_); +bookmarks::ManagedBookmarkService* +BookmarkMenuDelegate::GetManagedBookmarkService() { + return ManagedBookmarkServiceFactory::GetForProfile(profile_); } void BookmarkMenuDelegate::SetActiveMenu(const BookmarkNode* node, @@ -481,7 +483,7 @@ void BookmarkMenuDelegate::BuildMenuForPermanentNode( void BookmarkMenuDelegate::BuildMenuForManagedNode(MenuItemView* menu) { // Don't add a separator for this menu. bool added_separator = true; - const BookmarkNode* node = GetChromeBookmarkClient()->managed_node(); + const BookmarkNode* node = GetManagedBookmarkService()->managed_node(); BuildMenuForPermanentNode(node, IDR_BOOKMARK_BAR_FOLDER_MANAGED, menu, &added_separator); } @@ -489,7 +491,7 @@ void BookmarkMenuDelegate::BuildMenuForManagedNode(MenuItemView* menu) { void BookmarkMenuDelegate::BuildMenuForSupervisedNode(MenuItemView* menu) { // Don't add a separator for this menu. bool added_separator = true; - const BookmarkNode* node = GetChromeBookmarkClient()->supervised_node(); + const BookmarkNode* node = GetManagedBookmarkService()->supervised_node(); BuildMenuForPermanentNode(node, IDR_BOOKMARK_BAR_FOLDER_SUPERVISED, menu, &added_separator); } diff --git a/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.h b/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.h index 7b44bd9..4069aaf 100644 --- a/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.h +++ b/chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.h @@ -16,9 +16,12 @@ #include "ui/views/controls/menu/menu_delegate.h" class Browser; -class ChromeBookmarkClient; class Profile; +namespace bookmarks { +class ManagedBookmarkService; +} + namespace content { class PageNavigator; } @@ -74,7 +77,7 @@ class BookmarkMenuDelegate : public bookmarks::BaseBookmarkModelObserver, void SetActiveMenu(const bookmarks::BookmarkNode* node, int start_index); bookmarks::BookmarkModel* GetBookmarkModel(); - ChromeBookmarkClient* GetChromeBookmarkClient(); + bookmarks::ManagedBookmarkService* GetManagedBookmarkService(); // Returns the menu. views::MenuItemView* menu() { return menu_; } diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi index fa8c33b..206d305 100644 --- a/chrome/chrome_browser.gypi +++ b/chrome/chrome_browser.gypi @@ -1350,6 +1350,8 @@ 'browser/bookmarks/chrome_bookmark_client_factory.h', 'browser/bookmarks/enhanced_bookmarks_features.cc', 'browser/bookmarks/enhanced_bookmarks_features.h', + 'browser/bookmarks/managed_bookmark_service_factory.cc', + 'browser/bookmarks/managed_bookmark_service_factory.h', 'browser/bookmarks/startup_task_runner_service_factory.cc', 'browser/bookmarks/startup_task_runner_service_factory.h', 'browser/enhanced_bookmarks/bookmark_server_cluster_service_factory.cc', diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi index 39ed825..6c9a96f 100644 --- a/chrome/chrome_tests_unit.gypi +++ b/chrome/chrome_tests_unit.gypi @@ -37,7 +37,7 @@ 'browser/banners/app_banner_data_fetcher_unittest.cc', 'browser/banners/app_banner_settings_helper_unittest.cc', 'browser/bitmap_fetcher/bitmap_fetcher_service_unittest.cc', - 'browser/bookmarks/chrome_bookmark_client_unittest.cc', + 'browser/bookmarks/managed_bookmark_service_unittest.cc', 'browser/browser_about_handler_unittest.cc', 'browser/browser_process_impl_unittest.cc', 'browser/browsing_data/browsing_data_appcache_helper_unittest.cc', diff --git a/chrome/test/base/testing_profile.cc b/chrome/test/base/testing_profile.cc index c1badfb..976c7a8 100644 --- a/chrome/test/base/testing_profile.cc +++ b/chrome/test/base/testing_profile.cc @@ -18,6 +18,7 @@ #include "chrome/browser/bookmarks/bookmark_model_factory.h" #include "chrome/browser/bookmarks/chrome_bookmark_client.h" #include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h" +#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/chrome_notification_types.h" #include "chrome/browser/favicon/chrome_fallback_icon_client_factory.h" @@ -210,7 +211,7 @@ scoped_ptr<KeyedService> BuildInMemoryURLIndex( } scoped_ptr<KeyedService> BuildBookmarkModel(content::BrowserContext* context) { - Profile* profile = static_cast<Profile*>(context); + Profile* profile = Profile::FromBrowserContext(context); ChromeBookmarkClient* bookmark_client = ChromeBookmarkClientFactory::GetForProfile(profile); scoped_ptr<BookmarkModel> bookmark_model(new BookmarkModel(bookmark_client)); @@ -224,12 +225,6 @@ scoped_ptr<KeyedService> BuildBookmarkModel(content::BrowserContext* context) { return bookmark_model.Pass(); } -scoped_ptr<KeyedService> BuildChromeBookmarkClient( - content::BrowserContext* context) { - return make_scoped_ptr( - new ChromeBookmarkClient(static_cast<Profile*>(context))); -} - void TestProfileErrorCallback(WebDataServiceWrapper::ErrorType error_type, sql::InitStatus status) { NOTREACHED(); @@ -592,8 +587,10 @@ void TestingProfile::CreateBookmarkModel(bool delete_file) { base::FilePath path = GetPath().Append(bookmarks::kBookmarksFileName); base::DeleteFile(path, false); } + ManagedBookmarkServiceFactory::GetInstance()->SetTestingFactory( + this, ManagedBookmarkServiceFactory::GetDefaultFactory()); ChromeBookmarkClientFactory::GetInstance()->SetTestingFactory( - this, BuildChromeBookmarkClient); + this, ChromeBookmarkClientFactory::GetDefaultFactory()); // This creates the BookmarkModel. ignore_result(BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse( this, BuildBookmarkModel)); diff --git a/components/bookmarks.gypi b/components/bookmarks.gypi index eabb68a..3dc0c97 100644 --- a/components/bookmarks.gypi +++ b/components/bookmarks.gypi @@ -112,8 +112,11 @@ 'dependencies': [ 'bookmarks_browser', 'components_strings.gyp:components_strings', + 'keyed_service_core', ], 'sources': [ + 'bookmarks/managed/managed_bookmark_service.cc', + 'bookmarks/managed/managed_bookmark_service.h', 'bookmarks/managed/managed_bookmarks_tracker.cc', 'bookmarks/managed/managed_bookmarks_tracker.h', ], diff --git a/components/bookmarks/managed/BUILD.gn b/components/bookmarks/managed/BUILD.gn index 77a9f9eb..441ee67 100644 --- a/components/bookmarks/managed/BUILD.gn +++ b/components/bookmarks/managed/BUILD.gn @@ -4,6 +4,8 @@ source_set("managed") { sources = [ + "managed_bookmark_service.cc", + "managed_bookmark_service.h", "managed_bookmarks_tracker.cc", "managed_bookmarks_tracker.h", ] @@ -13,6 +15,7 @@ source_set("managed") { "//base:prefs", "//components/bookmarks/browser", "//components/bookmarks/common", + "//components/keyed_service/core", "//components/strings", "//ui/base", "//url", diff --git a/components/bookmarks/managed/managed_bookmark_service.cc b/components/bookmarks/managed/managed_bookmark_service.cc new file mode 100644 index 0000000..acf63ad --- /dev/null +++ b/components/bookmarks/managed/managed_bookmark_service.cc @@ -0,0 +1,183 @@ +// Copyright 2015 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/bookmarks/managed/managed_bookmark_service.h" + +#include <stdlib.h> +#include <vector> + +#include "base/bind.h" +#include "base/callback.h" +#include "base/logging.h" +#include "base/macros.h" +#include "base/memory/scoped_vector.h" +#include "base/strings/string16.h" +#include "base/values.h" +#include "components/bookmarks/browser/bookmark_model.h" +#include "components/bookmarks/browser/bookmark_utils.h" +#include "components/bookmarks/managed/managed_bookmarks_tracker.h" +#include "grit/components_strings.h" +#include "ui/base/l10n/l10n_util.h" + +namespace bookmarks { +namespace { + +// BookmarkPermanentNodeLoader initializes a BookmarkPermanentNode from a JSON +// representation, title id and starting node id. +class BookmarkPermanentNodeLoader { + public: + BookmarkPermanentNodeLoader(scoped_ptr<BookmarkPermanentNode> node, + scoped_ptr<base::ListValue> initial_bookmarks, + int title_id) + : node_(node.Pass()), + initial_bookmarks_(initial_bookmarks.Pass()), + title_id_(title_id) { + DCHECK(node_); + } + + ~BookmarkPermanentNodeLoader() {} + + // Initializes |node_| from |initial_bookmarks_| and |title_id_| and returns + // it. The ids are assigned starting at |next_node_id| and the value is + // updated as a side-effect. + scoped_ptr<BookmarkPermanentNode> Load(int64* next_node_id) { + node_->set_id(*next_node_id); + *next_node_id = ManagedBookmarksTracker::LoadInitial( + node_.get(), initial_bookmarks_.get(), node_->id() + 1); + node_->set_visible(!node_->empty()); + node_->SetTitle(l10n_util::GetStringUTF16(title_id_)); + return node_.Pass(); + } + + private: + scoped_ptr<BookmarkPermanentNode> node_; + scoped_ptr<base::ListValue> initial_bookmarks_; + int title_id_; + + DISALLOW_COPY_AND_ASSIGN(BookmarkPermanentNodeLoader); +}; + +// Returns a list of initialized BookmarkPermanentNodes using |next_node_id| to +// start assigning id. |next_node_id| is updated as a side effect of calling +// this method. +BookmarkPermanentNodeList LoadExtraNodes( + ScopedVector<BookmarkPermanentNodeLoader> loaders, + int64* next_node_id) { + BookmarkPermanentNodeList extra_nodes; + for (const auto& loader : loaders) + extra_nodes.push_back(loader->Load(next_node_id).release()); + return extra_nodes.Pass(); +} + +} // namespace + +ManagedBookmarkService::ManagedBookmarkService( + PrefService* prefs, + const GetManagementDomainCallback& callback) + : prefs_(prefs), + bookmark_model_(nullptr), + managed_domain_callback_(callback), + managed_node_(nullptr), + supervised_node_(nullptr) {} + +ManagedBookmarkService::~ManagedBookmarkService() { + DCHECK(!bookmark_model_); +} + +void ManagedBookmarkService::BookmarkModelCreated( + BookmarkModel* bookmark_model) { + DCHECK(bookmark_model); + DCHECK(!bookmark_model_); + bookmark_model_ = bookmark_model; + bookmark_model_->AddObserver(this); + + managed_bookmarks_tracker_.reset(new ManagedBookmarksTracker( + bookmark_model_, prefs_, false /* is_supervised */, + managed_domain_callback_)); + + GetManagementDomainCallback unbound_callback; + supervised_bookmarks_tracker_.reset(new ManagedBookmarksTracker( + bookmark_model_, prefs_, true /* is_supervised */, unbound_callback)); +} + +LoadExtraCallback ManagedBookmarkService::GetLoadExtraNodesCallback() { + // Create two BookmarkPermanentNode with a temporary id of 0. They will be + // populated and assigned proper ids in the LoadExtraNodes callback. Until + // then, they are owned by the returned closure. + scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0)); + scoped_ptr<BookmarkPermanentNode> supervised(new BookmarkPermanentNode(0)); + + managed_node_ = managed.get(); + supervised_node_ = supervised.get(); + + ScopedVector<BookmarkPermanentNodeLoader> loaders; + loaders.push_back(new BookmarkPermanentNodeLoader( + managed.Pass(), managed_bookmarks_tracker_->GetInitialManagedBookmarks(), + IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME)); + loaders.push_back(new BookmarkPermanentNodeLoader( + supervised.Pass(), + supervised_bookmarks_tracker_->GetInitialManagedBookmarks(), + IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME)); + + return base::Bind(&LoadExtraNodes, base::Passed(&loaders)); +} + +bool ManagedBookmarkService::CanSetPermanentNodeTitle( + const BookmarkNode* node) { + // |managed_node_| can have its title updated if the user signs in or out, + // since the name of the managed domain can appear in it. Also both + // |managed_node_| and |supervised_node_| can have their title updated on + // locale changes (http://crbug.com/459448). + if (node == managed_node_ || node == supervised_node_) + return true; + return !IsDescendantOf(node, managed_node_) && + !IsDescendantOf(node, supervised_node_); +} + +bool ManagedBookmarkService::CanSyncNode(const BookmarkNode* node) { + return !IsDescendantOf(node, managed_node_) && + !IsDescendantOf(node, supervised_node_); +} + +bool ManagedBookmarkService::CanBeEditedByUser(const BookmarkNode* node) { + return !IsDescendantOf(node, managed_node_) && + !IsDescendantOf(node, supervised_node_); +} + +void ManagedBookmarkService::Shutdown() { + Cleanup(); +} + +void ManagedBookmarkService::BookmarkModelChanged() {} + +void ManagedBookmarkService::BookmarkModelLoaded(BookmarkModel* bookmark_model, + bool ids_reassigned) { + BaseBookmarkModelObserver::BookmarkModelLoaded(bookmark_model, + ids_reassigned); + // Start tracking the managed and supervised bookmarks. This will detect any + // changes that may have occurred while the initial managed and supervised + // bookmarks were being loaded on the background. + managed_bookmarks_tracker_->Init(managed_node_); + supervised_bookmarks_tracker_->Init(supervised_node_); +} + +void ManagedBookmarkService::BookmarkModelBeingDeleted( + BookmarkModel* bookmark_model) { + Cleanup(); +} + +void ManagedBookmarkService::Cleanup() { + if (bookmark_model_) { + bookmark_model_->RemoveObserver(this); + bookmark_model_ = nullptr; + } + + managed_bookmarks_tracker_.reset(); + supervised_bookmarks_tracker_.reset(); + + managed_node_ = nullptr; + supervised_node_ = nullptr; +} + +} // namespace bookmarks diff --git a/components/bookmarks/managed/managed_bookmark_service.h b/components/bookmarks/managed/managed_bookmark_service.h new file mode 100644 index 0000000..8841c0d --- /dev/null +++ b/components/bookmarks/managed/managed_bookmark_service.h @@ -0,0 +1,102 @@ +// Copyright 2015 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_MANAGED_MANAGED_BOOKMARK_SERVICE_H_ +#define COMPONENTS_BOOKMARKS_MANAGED_MANAGED_BOOKMARK_SERVICE_H_ + +#include <string> + +#include "base/callback_forward.h" +#include "base/macros.h" +#include "base/memory/scoped_ptr.h" +#include "components/bookmarks/browser/base_bookmark_model_observer.h" +#include "components/bookmarks/browser/bookmark_node.h" +#include "components/bookmarks/browser/bookmark_storage.h" +#include "components/keyed_service/core/keyed_service.h" + +class PrefService; + +namespace bookmarks { + +class BookmarkModel; +class ManagedBookmarksTracker; + +// ManagedBookmarkService manages the bookmark folder controlled by enterprise +// policy or custodian of supervised users. +class ManagedBookmarkService : public KeyedService, + public BaseBookmarkModelObserver { + public: + typedef base::Callback<std::string()> GetManagementDomainCallback; + + ManagedBookmarkService(PrefService* prefs, + const GetManagementDomainCallback& callback); + ~ManagedBookmarkService() override; + + // Called upon creation of the BookmarkModel. + void BookmarkModelCreated(BookmarkModel* bookmark_model); + + // Returns a task that will be used to load any additional root nodes. This + // task will be invoked in the Profile's IO task runner. + LoadExtraCallback GetLoadExtraNodesCallback(); + + // Returns true if the |node| can have its title updated. + bool CanSetPermanentNodeTitle(const BookmarkNode* node); + + // Returns true if |node| should sync. + bool CanSyncNode(const BookmarkNode* node); + + // Returns true if |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); + + // Top-level managed bookmarks folder, defined by an enterprise policy; may be + // null. + const BookmarkNode* managed_node() { return managed_node_; } + + // Top-level supervised bookmarks folder, defined by the custodian of a + // supervised user; may be null. + const BookmarkNode* supervised_node() { return supervised_node_; } + + private: + // KeyedService implementation. + void Shutdown() override; + + // BaseBookmarkModelObserver implementation. + void BookmarkModelChanged() override; + + // BookmarkModelObserver implementation. + void BookmarkModelLoaded(bookmarks::BookmarkModel* bookmark_model, + bool ids_reassigned) override; + void BookmarkModelBeingDeleted(BookmarkModel* bookmark_model) override; + + // Cleanup, called when service is shutdown or when BookmarkModel is being + // destroyed. + void Cleanup(); + + // Pointer to the PrefService. Must outlive ManagedBookmarkService. + PrefService* prefs_; + + // Pointer to the BookmarkModel; may be null. Only valid between the calls to + // BookmarkModelCreated() and to BookmarkModelBeingDestroyed(). + BookmarkModel* bookmark_model_; + + // Managed bookmarks are defined by an enterprise policy. The lifetime of the + // BookmarkPermanentNode is controlled by BookmarkModel. + scoped_ptr<ManagedBookmarksTracker> managed_bookmarks_tracker_; + GetManagementDomainCallback managed_domain_callback_; + BookmarkPermanentNode* managed_node_; + + // Supervised bookmarks are defined by the custodian of a supervised user. The + // lifetime of the BookmarkPermanentNode is controlled by BookmarkModel. + scoped_ptr<ManagedBookmarksTracker> supervised_bookmarks_tracker_; + BookmarkPermanentNode* supervised_node_; + + DISALLOW_COPY_AND_ASSIGN(ManagedBookmarkService); +}; + +} // namespace bookmarks + +#endif // COMPONENTS_BOOKMARKS_MANAGED_MANAGED_BOOKMARK_SERVICE_H_ |