Add pyauto hooks for bookmarks.

Get model, add/remove, add folder, reparent, change title/url.

BUG=34492

Review URL: http://codereview.chromium.org/792003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@41450 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 301 insertions, 0 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 47db0d6..e083b60 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -18,6 +18,7 @@
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/thread.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/app_modal_dialog.h"
@@ -28,6 +29,8 @@
 #include "chrome/browser/automation/extension_automation_constants.h"
 #include "chrome/browser/automation/extension_port_container.h"
 #include "chrome/browser/blocked_popup_container.h"
+#include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_storage.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/chrome_thread.h"
@@ -409,6 +412,22 @@ void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
                         HandleFindWindowLocationRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_BookmarkBarVisibility,
                         GetBookmarkBarVisibility)
+    IPC_MESSAGE_HANDLER(AutomationMsg_GetBookmarksAsJSON,
+                        GetBookmarksAsJSON)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForBookmarkModelToLoad,
+                                    WaitForBookmarkModelToLoad)
+    IPC_MESSAGE_HANDLER(AutomationMsg_AddBookmarkGroup,
+                        AddBookmarkGroup)
+    IPC_MESSAGE_HANDLER(AutomationMsg_AddBookmarkURL,
+                        AddBookmarkURL)
+    IPC_MESSAGE_HANDLER(AutomationMsg_ReparentBookmark,
+                        ReparentBookmark)
+    IPC_MESSAGE_HANDLER(AutomationMsg_SetBookmarkTitle,
+                        SetBookmarkTitle)
+    IPC_MESSAGE_HANDLER(AutomationMsg_SetBookmarkURL,
+                        SetBookmarkURL)
+    IPC_MESSAGE_HANDLER(AutomationMsg_RemoveBookmark,
+                        RemoveBookmark)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetInfoBarCount, GetInfoBarCount)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_ClickInfoBarAccept,
                                     ClickInfoBarAccept)
@@ -1285,6 +1304,187 @@ void AutomationProvider::GetBookmarkBarVisibility(int handle,
   }
 }
 
+void AutomationProvider::GetBookmarksAsJSON(int handle,
+                                            std::string* bookmarks_as_json,
+                                            bool *success) {
+  *success = false;
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      if (!browser->profile()->GetBookmarkModel()->IsLoaded()) {
+        return;
+      }
+      scoped_refptr<BookmarkStorage> storage = new BookmarkStorage(
+          browser->profile(),
+          browser->profile()->GetBookmarkModel());
+      *success = storage->SerializeData(bookmarks_as_json);
+    }
+  }
+}
+
+void AutomationProvider::WaitForBookmarkModelToLoad(
+    int handle,
+    IPC::Message* reply_message) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    BookmarkModel* model = browser->profile()->GetBookmarkModel();
+    if (model->IsLoaded()) {
+      AutomationMsg_WaitForBookmarkModelToLoad::WriteReplyParams(
+          reply_message, true);
+      Send(reply_message);
+    } else {
+      // The observer will delete itself when done.
+      new AutomationProviderBookmarkModelObserver(this, reply_message,
+                                                  model);
+    }
+  }
+}
+
+void AutomationProvider::AddBookmarkGroup(int handle,
+                                          int64 parent_id, int index,
+                                          std::wstring title,
+                                          bool* success) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      if (!model->IsLoaded()) {
+        *success = false;
+        return;
+      }
+      const BookmarkNode* parent = model->GetNodeByID(parent_id);
+      DCHECK(parent);
+      if (parent) {
+        const BookmarkNode* child = model->AddGroup(parent, index,
+                                                    WideToUTF16(title));
+        DCHECK(child);
+        if (child)
+          *success = true;
+      }
+    }
+  }
+  *success = false;
+}
+
+void AutomationProvider::AddBookmarkURL(int handle,
+                                        int64 parent_id, int index,
+                                        std::wstring title, const GURL& url,
+                                        bool* success) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      if (!model->IsLoaded()) {
+        *success = false;
+        return;
+      }
+      const BookmarkNode* parent = model->GetNodeByID(parent_id);
+      DCHECK(parent);
+      if (parent) {
+        const BookmarkNode* child = model->AddURL(parent, index,
+                                                  WideToUTF16(title), url);
+        DCHECK(child);
+        if (child)
+          *success = true;
+      }
+    }
+  }
+  *success = false;
+}
+
+void AutomationProvider::ReparentBookmark(int handle,
+                                          int64 id, int64 new_parent_id,
+                                          int index,
+                                          bool* success) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      if (!model->IsLoaded()) {
+        *success = false;
+        return;
+      }
+      const BookmarkNode* node = model->GetNodeByID(id);
+      DCHECK(node);
+      const BookmarkNode* new_parent = model->GetNodeByID(new_parent_id);
+      DCHECK(new_parent);
+      if (node && new_parent) {
+        model->Move(node, new_parent, index);
+        *success = true;
+      }
+    }
+  }
+  *success = false;
+}
+
+void AutomationProvider::SetBookmarkTitle(int handle,
+                                          int64 id, std::wstring title,
+                                          bool* success) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      if (!model->IsLoaded()) {
+        *success = false;
+        return;
+      }
+      const BookmarkNode* node = model->GetNodeByID(id);
+      DCHECK(node);
+      if (node) {
+        model->SetTitle(node, WideToUTF16(title));
+        *success = true;
+      }
+    }
+  }
+  *success = false;
+}
+
+void AutomationProvider::SetBookmarkURL(int handle,
+                                        int64 id, const GURL& url,
+                                        bool* success) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      if (!model->IsLoaded()) {
+        *success = false;
+        return;
+      }
+      const BookmarkNode* node = model->GetNodeByID(id);
+      DCHECK(node);
+      if (node) {
+        model->SetURL(node, url);
+        *success = true;
+      }
+    }
+  }
+  *success = false;
+}
+
+void AutomationProvider::RemoveBookmark(int handle,
+                                        int64 id,
+                                        bool* success) {
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    if (browser) {
+      BookmarkModel* model = browser->profile()->GetBookmarkModel();
+      if (!model->IsLoaded()) {
+        *success = false;
+        return;
+      }
+      const BookmarkNode* node = model->GetNodeByID(id);
+      DCHECK(node);
+      if (node) {
+        const BookmarkNode* parent = node->GetParent();
+        DCHECK(parent);
+        model->Remove(parent, parent->IndexOfChild(node));
+        *success = true;
+      }
+    }
+  }
+  *success = false;
+}
+
 void AutomationProvider::HandleInspectElementRequest(
     int handle, int x, int y, IPC::Message* reply_message) {
   TabContents* tab_contents = GetTabContentsForHandle(handle, NULL);
diff --git a/chrome/browser/automation/automation_provider.h b/chrome/browser/automation/automation_provider.h
index 6d08f38..88bb865 100644
--- a/chrome/browser/automation/automation_provider.h
+++ b/chrome/browser/automation/automation_provider.h
@@ -285,6 +285,38 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
   // Get the visibility state of the Bookmark bar.
   void GetBookmarkBarVisibility(int handle, bool* visible, bool* animating);
 
+  // Get the bookmarks as a JSON string.
+  void GetBookmarksAsJSON(int handle, std::string* bookmarks_as_json,
+                          bool *success);
+
+  // Wait for the bookmark model to load.
+  void WaitForBookmarkModelToLoad(int handle, IPC::Message* reply_message);
+
+  // Set |loaded| to true if the bookmark model has loaded, else false.
+  void BookmarkModelHasLoaded(int handle, bool* loaded);
+
+  // Editing, modification, and removal of bookmarks.
+  // Bookmarks are referenced by id.
+  void AddBookmarkGroup(int handle,
+                        int64 parent_id, int index, std::wstring title,
+                        bool* success);
+  void AddBookmarkURL(int handle,
+                      int64 parent_id, int index,
+                      std::wstring title, const GURL& url,
+                      bool* success);
+  void ReparentBookmark(int handle,
+                        int64 id, int64 new_parent_id, int index,
+                        bool* success);
+  void SetBookmarkTitle(int handle,
+                        int64 id, std::wstring title,
+                        bool* success);
+  void SetBookmarkURL(int handle,
+                      int64 id, const GURL& url,
+                      bool* success);
+  void RemoveBookmark(int handle,
+                      int64 id,
+                      bool* success);
+
   // Responds to InspectElement request
   void HandleInspectElementRequest(int handle,
                                    int x,
diff --git a/chrome/browser/automation/automation_provider_observers.cc b/chrome/browser/automation/automation_provider_observers.cc
index 9c5f656..7f1f4f5 100644
--- a/chrome/browser/automation/automation_provider_observers.cc
+++ b/chrome/browser/automation/automation_provider_observers.cc
@@ -7,6 +7,7 @@
 #include "base/basictypes.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/automation/automation_provider.h"
+#include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/login_prompt.h"
 #include "chrome/browser/metrics/metric_event_duration_details.h"
@@ -743,3 +744,24 @@ void LoginManagerObserver::Observe(NotificationType type,
   delete this;
 }
 #endif
+
+AutomationProviderBookmarkModelObserver::AutomationProviderBookmarkModelObserver(
+    AutomationProvider* provider,
+    IPC::Message* reply_message,
+    BookmarkModel* model) {
+  automation_provider_ = provider;
+  reply_message_ = reply_message;
+  model_ = model;
+  model_->AddObserver(this);
+}
+
+AutomationProviderBookmarkModelObserver::~AutomationProviderBookmarkModelObserver() {
+  model_->RemoveObserver(this);
+}
+
+void AutomationProviderBookmarkModelObserver::ReplyAndDelete(bool success) {
+  AutomationMsg_WaitForBookmarkModelToLoad::WriteReplyParams(
+      reply_message_, success);
+  automation_provider_->Send(reply_message_);
+  delete this;
+}
diff --git a/chrome/browser/automation/automation_provider_observers.h b/chrome/browser/automation/automation_provider_observers.h
index 79c824d..0d75e70 100644
--- a/chrome/browser/automation/automation_provider_observers.h
+++ b/chrome/browser/automation/automation_provider_observers.h
@@ -8,6 +8,7 @@
 #include <map>
 #include <set>
 
+#include "chrome/browser/bookmarks/bookmark_model_observer.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_type.h"
@@ -405,4 +406,50 @@ class LoginManagerObserver : public NotificationObserver {
 };
 #endif
 
+// Waits for the bookmark model to load.
+class AutomationProviderBookmarkModelObserver : BookmarkModelObserver {
+ public:
+  AutomationProviderBookmarkModelObserver(AutomationProvider* provider,
+                                          IPC::Message* reply_message,
+                                          BookmarkModel* model);
+  virtual ~AutomationProviderBookmarkModelObserver();
+
+  virtual void Loaded(BookmarkModel* model) {
+    ReplyAndDelete(true);
+  }
+  virtual void BookmarkModelBeingDeleted(BookmarkModel* model) {
+    ReplyAndDelete(false);
+  }
+  virtual void BookmarkNodeMoved(BookmarkModel* model,
+                                 const BookmarkNode* old_parent,
+                                 int old_index,
+                                 const BookmarkNode* new_parent,
+                                 int new_index) {}
+  virtual void BookmarkNodeAdded(BookmarkModel* model,
+                                 const BookmarkNode* parent,
+                                 int index) {}
+  virtual void BookmarkNodeRemoved(BookmarkModel* model,
+                                   const BookmarkNode* parent,
+                                   int old_index,
+                                   const BookmarkNode* node) {}
+  virtual void BookmarkNodeChanged(BookmarkModel* model,
+                                   const BookmarkNode* node) {}
+  virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
+                                         const BookmarkNode* node) {}
+  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
+                                             const BookmarkNode* node) {}
+
+ private:
+  // Reply to the automation message with the given success value,
+  // then delete myself (which removes myself from the bookmark model
+  // observer list).
+  void ReplyAndDelete(bool success);
+
+  scoped_refptr<AutomationProvider> automation_provider_;
+  IPC::Message* reply_message_;
+  BookmarkModel* model_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutomationProviderBookmarkModelObserver);
+};
+
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_