Add the webui handler for Android's bookmark section on the NTP.

chrome/browser/ui/webui/ntp/android/bookmarks_handler.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/ui/webui/ntp/android/bookmarks_handler.h"
+
+#include "base/logging.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "chrome/browser/android/tab_android.h"
+#include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/webui/chrome_url_data_manager.h"
+#include "chrome/browser/ui/webui/favicon_source.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/color_analysis.h"
+
+using base::Int64ToString;
+using content::BrowserThread;
+
+namespace {
+
+static const char* kParentIdParam = "parent_id";
+static const char* kNodeIdParam = "node_id";
+
+// Parses a bookmark ID passed back from the NTP.  The IDs differ from the
+// normal int64 bookmark ID because we prepend a "p" if the ID represents a
+// partner bookmark.
+bool ParseNtpBookmarkId(const ListValue* args,
+                        int64* out_id,
+                        bool* out_is_partner) {
+  std::string string_id;
+  if (!args->GetString(0, &string_id))
+    return false;
+
+  if (string_id.empty())
+    return false;
+
+  if (StartsWithASCII(string_id, "p", true)) {
+    *out_is_partner = true;
+    return base::StringToInt64(string_id.substr(1), out_id);
+  } else {
+    *out_is_partner = false;
+    return base::StringToInt64(string_id, out_id);
+  }
+}
+
+std::string BookmarkTypeAsString(BookmarkNode::Type type) {
+  switch (type) {
+    case BookmarkNode::URL:
+      return "URL";
+    case BookmarkNode::FOLDER:
+      return "FOLDER";
+    case BookmarkNode::BOOKMARK_BAR:
+      return "BOOKMARK_BAR";
+    case BookmarkNode::OTHER_NODE:
+      return "OTHER_NODE";
+    case BookmarkNode::MOBILE:
+      return "MOBILE";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+SkColor GetDominantColorForFavicon(scoped_refptr<base::RefCountedMemory> png) {
+  color_utils::GridSampler sampler;
+  // 100 here is the darkness_limit which represents the minimum sum of the RGB
+  // components that is acceptable as a color choice. This can be from 0 to 765.
+  // 665 here is the brightness_limit represents the maximum sum of the RGB
+  // components that is acceptable as a color choice. This can be from 0 to 765.
+  return color_utils::CalculateKMeanColorOfPNG(png, 100, 665, sampler);
+}
+
+}  // namespace
+
+BookmarksHandler::BookmarksHandler()
+    : bookmark_model_(NULL),
+      partner_bookmarks_shim_(NULL),
+      bookmark_data_requested_(false),
+      extensive_changes_(false),
+      creating_shortcut_(false) {
+}
+
+BookmarksHandler::~BookmarksHandler() {
+  if (bookmark_model_)
+    bookmark_model_->RemoveObserver(this);
+
+  if (partner_bookmarks_shim_)
+    partner_bookmarks_shim_->RemoveObserver(this);
+}
+
+void BookmarksHandler::RegisterMessages() {
+  // Listen for the bookmark change. We need the both bookmark and folder
+  // change, the NotificationService is not sufficient.
+  Profile* profile = Profile::FromBrowserContext(
+      web_ui()->GetWebContents()->GetBrowserContext());
+
+  ChromeURLDataManager::AddDataSource(profile,
+      new FaviconSource(profile, FaviconSource::ANY));
+
+  bookmark_model_ = BookmarkModelFactory::GetForProfile(profile);
+  if (bookmark_model_) {
+    bookmark_model_->AddObserver(this);
+    // Since a sync or import could have started before this class is
+    // initialized, we need to make sure that our initial state is
+    // up to date.
+    extensive_changes_ = bookmark_model_->IsDoingExtensiveChanges();
+  }
+
+  // Create the partner Bookmarks shim as early as possible (but don't attach).
+  if (!partner_bookmarks_shim_) {
+    partner_bookmarks_shim_ = PartnerBookmarksShim::GetInstance();
+    partner_bookmarks_shim_->AddObserver(this);
+  }
+
+  // Register ourselves as the handler for the bookmark javascript callbacks.
+  web_ui()->RegisterMessageCallback("getBookmarks",
+      base::Bind(&BookmarksHandler::HandleGetBookmarks,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("deleteBookmark",
+      base::Bind(&BookmarksHandler::HandleDeleteBookmark,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("shortcutToBookmark",
+      base::Bind(&BookmarksHandler::HandleShortcutToBookmark,
+                 base::Unretained(this)));
+}
+
+void BookmarksHandler::HandleGetBookmarks(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  bookmark_data_requested_ = true;
+  Profile* profile = Profile::FromBrowserContext(
+      web_ui()->GetWebContents()->GetBrowserContext());
+  if (!BookmarkModelFactory::GetForProfile(profile)->IsLoaded())
+    return;  // is handled in Loaded().
+
+  // Attach the Partner Bookmarks shim under the Mobile Bookmarks.
+  // Cannot do this earlier because mobile_node is not yet set.
+  DCHECK(partner_bookmarks_shim_ != NULL);
+  if (bookmark_model_)
+    partner_bookmarks_shim_->AttachTo(
+        bookmark_model_, bookmark_model_->mobile_node());
+  if (!partner_bookmarks_shim_->IsLoaded())
+    return; // is handled with a PartnerShimLoaded() callback
+
+  int64 id;
+  bool is_partner;
+  if (args && !args->empty() && ParseNtpBookmarkId(args, &id, &is_partner))
+    QueryBookmarkFolder(id, is_partner);
+  else
+    QueryInitialBookmarks();
+}
+
+void BookmarksHandler::HandleDeleteBookmark(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  int64 id;
+  bool is_partner;
+  if (args && !args->empty() && ParseNtpBookmarkId(args, &id, &is_partner)) {
+    DCHECK(!is_partner);
+    const BookmarkNode* node = bookmark_model_->GetNodeByID(id);
+    if (node && node->parent()) {
+      const BookmarkNode* parent_node = node->parent();
+      bookmark_model_->Remove(parent_node, parent_node->GetIndexOf(node));
+    }
+  }
+}
+
+std::string BookmarksHandler::GetBookmarkIdForNtp(const BookmarkNode* node) {
+  if (partner_bookmarks_shim_->IsPartnerBookmark(node))
+    return "p" + Int64ToString(node->id());
+  return Int64ToString(node->id());
+}
+
+void BookmarksHandler::SetParentInBookmarksResult(const BookmarkNode& parent,
+                                                  DictionaryValue* result) {
+  result->SetString(kParentIdParam, GetBookmarkIdForNtp(&parent));
+}
+
+void BookmarksHandler::PopulateBookmark(const BookmarkNode* node,
+                                        ListValue* result) {
+  if (!result)
+    return;
+
+  DictionaryValue* filler_value = new DictionaryValue();
+  filler_value->SetString("title", node->GetTitle());
+  // Mark reserved system nodes and partner bookmarks as uneditable
+  // (i.e. the bookmark bar along with the "Other Bookmarks" folder).
+  filler_value->SetBoolean("editable",
+                           partner_bookmarks_shim_->IsBookmarkEditable(node));
+  if (node->is_url()) {
+    filler_value->SetBoolean("folder", false);
+    filler_value->SetString("url", node->url().spec());
+  } else {
+    filler_value->SetBoolean("folder", true);
+  }
+  filler_value->SetString("id", GetBookmarkIdForNtp(node));
+  filler_value->SetString("type", BookmarkTypeAsString(node->type()));
+  result->Append(filler_value);
+}
+
+void BookmarksHandler::PopulateBookmarksInFolder(
+    const BookmarkNode* folder,
+    const scoped_ptr<DictionaryValue>& result) {
+  scoped_ptr<ListValue> bookmarks(new ListValue);
+
+  for (int i = 0; i < folder->child_count(); i++) {
+    const BookmarkNode* bookmark=
+        (const BookmarkNode*) folder->GetChild(i);
+    PopulateBookmark(bookmark, bookmarks.get());
+  }
+
+  // Make sure we iterate over the partner's attach point
+  DCHECK(partner_bookmarks_shim_ != NULL);
+  if (partner_bookmarks_shim_->HasPartnerBookmarks() &&
+      folder == partner_bookmarks_shim_->get_attach_point()) {
+    PopulateBookmark(
+        partner_bookmarks_shim_->GetPartnerBookmarksRoot(), bookmarks.get());
+  }
+
+  scoped_ptr<ListValue> folder_hierarchy(new ListValue);
+  const BookmarkNode* parent = partner_bookmarks_shim_->GetParentOf(folder);
+
+  while (parent != NULL) {
+    scoped_ptr<DictionaryValue> hierarchy_entry(new DictionaryValue);
+    if (partner_bookmarks_shim_->IsRootNode(parent))
+      hierarchy_entry->SetBoolean("root", true);
+
+    hierarchy_entry->SetString("title", parent->GetTitle());
+    hierarchy_entry->SetString("id", GetBookmarkIdForNtp(parent));
+    folder_hierarchy->Append(hierarchy_entry.release());
+    parent = partner_bookmarks_shim_->GetParentOf(parent);
+  }
+
+  result->SetString("title", folder->GetTitle());
+  result->SetString("id", GetBookmarkIdForNtp(folder));
+  result->SetBoolean("root", partner_bookmarks_shim_->IsRootNode(folder));
+  result->Set("bookmarks", bookmarks.release());
+  result->Set("hierarchy", folder_hierarchy.release());
+}
+
+void BookmarksHandler::QueryBookmarkFolder(const int64& folder_id,
+                                           bool is_partner_bookmark) {
+  DCHECK(partner_bookmarks_shim_ != NULL);
+  const BookmarkNode* bookmarks =
+      partner_bookmarks_shim_->GetNodeByID(folder_id, is_partner_bookmark);
+  if (bookmarks) {
+    scoped_ptr<DictionaryValue> result(new DictionaryValue);
+    PopulateBookmarksInFolder(bookmarks, result);
+    SendResult(result);
+  } else {
+    // If we receive an ID that no longer maps to a bookmark folder, just
+    // return the initial bookmark folder.
+    QueryInitialBookmarks();
+  }
+}
+
+void BookmarksHandler::QueryInitialBookmarks() {
+  scoped_ptr<DictionaryValue> result(new DictionaryValue);
+  DCHECK(partner_bookmarks_shim_ != NULL);
+  PopulateBookmarksInFolder(
+      // We have to go to the partner Root if it exists
+      partner_bookmarks_shim_->HasPartnerBookmarks() ?
+          partner_bookmarks_shim_->GetPartnerBookmarksRoot() :
+          bookmark_model_->mobile_node(),
+      result);
+  SendResult(result);
+}
+
+void BookmarksHandler::SendResult(const scoped_ptr<DictionaryValue>& result) {
+  if (result.get())
+    web_ui()->CallJavascriptFunction("ntp.bookmarks", *(result.get()));
+}
+
+void BookmarksHandler::Loaded(BookmarkModel* model, bool ids_reassigned) {
+  BookmarkModelChanged();
+}
+
+void BookmarksHandler::PartnerShimLoaded(PartnerBookmarksShim* shim) {
+  BookmarkModelChanged();
+}
+
+void BookmarksHandler::ShimBeingDeleted(PartnerBookmarksShim* shim) {
+  partner_bookmarks_shim_ = NULL;
+}
+
+void BookmarksHandler::ExtensiveBookmarkChangesBeginning(BookmarkModel* model) {
+  extensive_changes_ = true;
+}
+
+void BookmarksHandler::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
+  extensive_changes_ = false;
+  BookmarkModelChanged();
+}
+
+void BookmarksHandler::BookmarkNodeRemoved(BookmarkModel* model,
+                                           const BookmarkNode* parent,
+                                           int old_index,
+                                           const BookmarkNode* node) {
+  DictionaryValue result;
+  SetParentInBookmarksResult(*parent, &result);
+  result.SetString(kNodeIdParam, Int64ToString(node->id()));
+  NotifyModelChanged(result);
+}
+
+void BookmarksHandler::BookmarkNodeAdded(BookmarkModel* model,
+                                         const BookmarkNode* parent,
+                                         int index) {
+  DictionaryValue result;
+  SetParentInBookmarksResult(*parent, &result);
+  NotifyModelChanged(result);
+}
+
+void BookmarksHandler::BookmarkNodeChanged(BookmarkModel* model,
+                                           const BookmarkNode* node) {
+  DCHECK(partner_bookmarks_shim_);
+  DCHECK(!partner_bookmarks_shim_->IsPartnerBookmark(node));
+  DictionaryValue result;
+  SetParentInBookmarksResult(*(node->parent()), &result);

[Evan Stade, 2012/08/15 00:05:10]

parens around node->parent() not necessary

[Ted C, 2012/08/15 21:21:00]

Done.

+  result.SetString(kNodeIdParam, Int64ToString(node->id()));
+  NotifyModelChanged(result);
+}
+
+void BookmarksHandler::BookmarkModelChanged() {
+  if (bookmark_data_requested_ && !extensive_changes_)
+    web_ui()->CallJavascriptFunction("ntp.bookmarkChanged");
+}
+
+void BookmarksHandler::NotifyModelChanged(const DictionaryValue& status) {
+  if (bookmark_data_requested_ && !extensive_changes_)
+    web_ui()->CallJavascriptFunction("ntp.bookmarkChanged", status);

[Evan Stade, 2012/08/15 00:05:10]

what is status used for? why is it needed here but not above

[Ted C, 2012/08/15 21:21:00]

Status allows us to tell the NTP what exact node was affected so it can refresh
selectively.  In the above case, we don't have the change information, so we
just tell the NTP to refresh whatever view it is on.

+}
+
+void BookmarksHandler::HandleShortcutToBookmark(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  Profile* profile = Profile::FromBrowserContext(
+      web_ui()->GetWebContents()->GetBrowserContext());
+  if (!profile)
+    return;
+
+  int64 id;
+  bool is_partner;
+  if (args && !args->empty() && ParseNtpBookmarkId(args, &id, &is_partner)) {
+    DCHECK(partner_bookmarks_shim_ != NULL);
+    BookmarkNode* node = const_cast<BookmarkNode*>(
+        partner_bookmarks_shim_->GetNodeByID(id, is_partner));
+    if (!node)
+      return;
+
+    creating_shortcut_ = true;
+    FaviconService* favicon_service = profile->GetFaviconService(
+        Profile::EXPLICIT_ACCESS);
+    FaviconService::Handle handle = favicon_service->GetFaviconForURL(
+        node->url(),
+        history::FAVICON | history::TOUCH_ICON,
+        &cancelable_consumer_,
+        base::Bind(&BookmarksHandler::OnFaviconDataAvailable,
+                   base::Unretained(this)));
+    cancelable_consumer_.SetClientData(favicon_service, handle, node);
+  }
+}
+
+void BookmarksHandler::OnFaviconDataAvailable(
+    FaviconService::Handle handle,
+    history::FaviconData favicon) {
+  if (!creating_shortcut_)

[Evan Stade, 2012/08/15 00:05:10]

why is this necessary?

[Ted C, 2012/08/15 21:21:00]

I think it was here for legacy reasons.  I removed the check and renamed the
method to make it explicit when it should be used.

+    return;
+
+  SkColor color = SK_ColorWHITE;
+  SkBitmap favicon_bitmap;
+  if (favicon.is_valid()) {
+    color = GetDominantColorForFavicon(favicon.image_data);
+    gfx::PNGCodec::Decode(favicon.image_data->front(),
+                          favicon.image_data->size(),
+                          &favicon_bitmap);
+  }
+
+  Profile* profile = Profile::FromBrowserContext(
+      web_ui()->GetWebContents()->GetBrowserContext());
+  BookmarkNode* node = cancelable_consumer_.GetClientData(
+      profile->GetFaviconService(Profile::EXPLICIT_ACCESS), handle);
+
+  TabAndroid* tab = TabAndroid::FromWebContents(
+      web_ui()->GetWebContents());
+  if (tab) {
+    tab->AddShortcutToBookmark(node->url(), node->GetTitle(),
+                               favicon_bitmap, SkColorGetR(color),
+                               SkColorGetG(color), SkColorGetB(color));
+  }
+  creating_shortcut_ = false;
+}