Add GetMessageHandlers to HtmlDialogUIDelegate to allow...

chrome/browser/dom_ui/new_tab_ui.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #include "chrome/browser/dom_ui/new_tab_ui.h"
 
 #include "app/animation.h"
 #include "app/l10n_util.h"
@@ skipping 440 matching lines @@
   SendResponse(request_id, html_bytes);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // MostVisitedHandler
 
 // The handler for Javascript messages related to the "most visited" view.
 class MostVisitedHandler : public DOMMessageHandler,
                            public NotificationObserver {
  public:
-  explicit MostVisitedHandler(DOMUI* dom_ui);
-  virtual ~MostVisitedHandler();
+  MostVisitedHandler() : url_blacklist_(NULL), pinned_urls_(NULL) { }
+  virtual ~MostVisitedHandler() { }
+
+  // DOMMessageHandler override and implementation.
+  virtual DOMMessageHandler* Attach(DOMUI* dom_ui);
+  virtual void RegisterMessages();
 
   // Callback for the "getMostVisited" message.
   void HandleGetMostVisited(const Value* value);
 
   // Callback for the "blacklistURLFromMostVisited" message.
   void HandleBlacklistURL(const Value* url);
 
   // Callback for the "removeURLsFromMostVisitedBlacklist" message.
   void HandleRemoveURLsFromBlacklist(const Value* url);
 
@@ skipping 53 matching lines @@
   DictionaryValue* url_blacklist_;
 
   // This is a dictionary for the pinned URLs for the the most visited part of
   // the new tab page. The key of the dictionary is a hash of the URL and the
   // value is a dictionary with title, url and index.
   DictionaryValue* pinned_urls_;
 
   DISALLOW_COPY_AND_ASSIGN(MostVisitedHandler);
 };
 
-MostVisitedHandler::MostVisitedHandler(DOMUI* dom_ui)
-    : DOMMessageHandler(dom_ui) {
-  // Register ourselves as the handler for the "mostvisited" message from
-  // Javascript.
-  dom_ui_->RegisterMessageCallback("getMostVisited",
-      NewCallback(this, &MostVisitedHandler::HandleGetMostVisited));
-
-  // Register ourselves for any most-visited item blacklisting.
-  dom_ui_->RegisterMessageCallback("blacklistURLFromMostVisited",
-      NewCallback(this, &MostVisitedHandler::HandleBlacklistURL));
-  dom_ui_->RegisterMessageCallback("removeURLsFromMostVisitedBlacklist",
-      NewCallback(this, &MostVisitedHandler::HandleRemoveURLsFromBlacklist));
-  dom_ui_->RegisterMessageCallback("clearMostVisitedURLsBlacklist",
-      NewCallback(this, &MostVisitedHandler::HandleClearBlacklist));
-
-  url_blacklist_ = dom_ui_->GetProfile()->GetPrefs()->
+DOMMessageHandler* MostVisitedHandler::Attach(DOMUI* dom_ui) {
+  url_blacklist_ = dom_ui->GetProfile()->GetPrefs()->
       GetMutableDictionary(prefs::kNTPMostVisitedURLsBlacklist);
-
-  // Register ourself for pinned URL messages.
-  dom_ui->RegisterMessageCallback("addPinnedURL",
-      NewCallback(this, &MostVisitedHandler::HandleAddPinnedURL));
-  dom_ui->RegisterMessageCallback("removePinnedURL",
-      NewCallback(this, &MostVisitedHandler::HandleRemovePinnedURL));
-
-  pinned_urls_ = dom_ui_->GetProfile()->GetPrefs()->
-    GetMutableDictionary(prefs::kNTPMostVisitedPinnedURLs);
-
+  pinned_urls_ = dom_ui->GetProfile()->GetPrefs()->
+      GetMutableDictionary(prefs::kNTPMostVisitedPinnedURLs);
   // Set up our sources for thumbnail and favicon data. Since we may be in
   // testing mode with no I/O thread, only add our handler when an I/O thread
   // exists. Ownership is passed to the ChromeURLDataManager.
   if (g_browser_process->io_thread()) {
     g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(&chrome_url_data_manager,
                           &ChromeURLDataManager::AddDataSource,
                           new DOMUIThumbnailSource(dom_ui->GetProfile())));
     g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(&chrome_url_data_manager,
                           &ChromeURLDataManager::AddDataSource,
                           new DOMUIFavIconSource(dom_ui->GetProfile())));
   }
 
   // Get notifications when history is cleared.
   registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
-                 Source<Profile>(dom_ui_->GetProfile()));
+      Source<Profile>(dom_ui->GetProfile()));
+
+  return DOMMessageHandler::Attach(dom_ui);
 }
 
-MostVisitedHandler::~MostVisitedHandler() {
+void MostVisitedHandler::RegisterMessages() {
+  // Register ourselves as the handler for the "mostvisited" message from
+  // Javascript.
+  dom_ui_->RegisterMessageCallback("getMostVisited",
+      NewCallback(this, &MostVisitedHandler::HandleGetMostVisited));
+
+  // Register ourselves for any most-visited item blacklisting.
+  dom_ui_->RegisterMessageCallback("blacklistURLFromMostVisited",
+      NewCallback(this, &MostVisitedHandler::HandleBlacklistURL));
+  dom_ui_->RegisterMessageCallback("removeURLsFromMostVisitedBlacklist",
+      NewCallback(this, &MostVisitedHandler::HandleRemoveURLsFromBlacklist));
+  dom_ui_->RegisterMessageCallback("clearMostVisitedURLsBlacklist",
+      NewCallback(this, &MostVisitedHandler::HandleClearBlacklist));
+
+  // Register ourself for pinned URL messages.
+  dom_ui_->RegisterMessageCallback("addPinnedURL",
+      NewCallback(this, &MostVisitedHandler::HandleAddPinnedURL));
+  dom_ui_->RegisterMessageCallback("removePinnedURL",
+      NewCallback(this, &MostVisitedHandler::HandleRemovePinnedURL));
 }
 
 void MostVisitedHandler::HandleGetMostVisited(const Value* value) {
   const int kMostVisitedCount = 9;
   // Let's query for the number of items we want plus the blacklist size as
   // we'll be filtering-out the returned list with the blacklist URLs.
   // We do not subtract the number of pinned URLs we have because the
   // HistoryService does not know about those.
   int result_count = kMostVisitedCount + url_blacklist_->GetSize();
   HistoryService* hs =
@@ skipping 228 matching lines @@
   prefs->RegisterDictionaryPref(prefs::kNTPMostVisitedPinnedURLs);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TemplateURLHandler
 
 // The handler for Javascript messages related to the "common searches" view.
 class TemplateURLHandler : public DOMMessageHandler,
                            public TemplateURLModelObserver {
  public:
-  explicit TemplateURLHandler(DOMUI* dom_ui);
+  TemplateURLHandler() : DOMMessageHandler(), template_url_model_(NULL) { }
   virtual ~TemplateURLHandler();
 
+  // DOMMessageHandler implementation.
+  virtual void RegisterMessages();
+
   // Callback for the "getMostSearched" message, sent when the page requests
   // the list of available searches.
   void HandleGetMostSearched(const Value* content);
   // Callback for the "doSearch" message, sent when the user wants to
   // run a search.  Content of the message is an array containing
   // [<the search keyword>, <the search term>].
   void HandleDoSearch(const Value* content);
 
   // TemplateURLModelObserver implementation.
   virtual void OnTemplateURLModelChanged();
 
  private:
-  DOMUI* dom_ui_;
   TemplateURLModel* template_url_model_;  // Owned by profile.
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLHandler);
 };
 
-TemplateURLHandler::TemplateURLHandler(DOMUI* dom_ui)
-    : DOMMessageHandler(dom_ui),
-      dom_ui_(dom_ui),
-      template_url_model_(NULL) {
-  dom_ui->RegisterMessageCallback("getMostSearched",
-      NewCallback(this, &TemplateURLHandler::HandleGetMostSearched));
-  dom_ui->RegisterMessageCallback("doSearch",
-      NewCallback(this, &TemplateURLHandler::HandleDoSearch));
-}
-
 TemplateURLHandler::~TemplateURLHandler() {
   if (template_url_model_)
     template_url_model_->RemoveObserver(this);
 }
 
+void TemplateURLHandler::RegisterMessages() {
+  dom_ui_->RegisterMessageCallback("getMostSearched",
+      NewCallback(this, &TemplateURLHandler::HandleGetMostSearched));
+  dom_ui_->RegisterMessageCallback("doSearch",
+      NewCallback(this, &TemplateURLHandler::HandleDoSearch));
+}
+
 void TemplateURLHandler::HandleGetMostSearched(const Value* content) {
   // The page Javascript has requested the list of keyword searches.
   // Start loading them from the template URL backend.
   if (!template_url_model_) {
     template_url_model_ = dom_ui_->GetProfile()->GetTemplateURLModel();
     template_url_model_->AddObserver(this);
   }
   if (template_url_model_->loaded()) {
     OnTemplateURLModelChanged();
   } else {
@@ skipping 105 matching lines @@
   UMA_HISTOGRAM_COUNTS("NewTabPage.SearchURLs.Total", urls_value.GetSize());
   dom_ui_->CallJavascriptFunction(L"searchURLs", urls_value);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RecentlyBookmarkedHandler
 
 class RecentlyBookmarkedHandler : public DOMMessageHandler,
                                   public BookmarkModelObserver {
  public:
-  explicit RecentlyBookmarkedHandler(DOMUI* dom_ui);
-  ~RecentlyBookmarkedHandler();
+  RecentlyBookmarkedHandler() : model_(NULL) { }
+  virtual ~RecentlyBookmarkedHandler();
+
+  // DOMMessageHandler implementation.
+  virtual void RegisterMessages();  
 
   // Callback which navigates to the bookmarks page.
   void HandleShowBookmarkPage(const Value*);
 
   // Callback for the "getRecentlyBookmarked" message.
   // It takes no arguments.
   void HandleGetRecentlyBookmarked(const Value*);
 
  private:
   void SendBookmarksToPage();
@@ skipping 13 matching lines @@
   virtual void BookmarkNodeMoved(BookmarkModel* model,
                                  BookmarkNode* old_parent,
                                  int old_index,
                                  BookmarkNode* new_parent,
                                  int new_index) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
                                              BookmarkNode* node) {}
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                          BookmarkNode* node) {}
 
-  DOMUI* dom_ui_;
   // The model we're getting bookmarks from. The model is owned by the Profile.
   BookmarkModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentlyBookmarkedHandler);
 };
 
-RecentlyBookmarkedHandler::RecentlyBookmarkedHandler(DOMUI* dom_ui)
-    : DOMMessageHandler(dom_ui),
-      dom_ui_(dom_ui),
-      model_(NULL) {
-  dom_ui->RegisterMessageCallback("getRecentlyBookmarked",
-      NewCallback(this,
-                  &RecentlyBookmarkedHandler::HandleGetRecentlyBookmarked));
-}
-
 RecentlyBookmarkedHandler::~RecentlyBookmarkedHandler() {
   if (model_)
     model_->RemoveObserver(this);
 }
 
+void RecentlyBookmarkedHandler::RegisterMessages() {
+  dom_ui_->RegisterMessageCallback("getRecentlyBookmarked",
+      NewCallback(this,
+                  &RecentlyBookmarkedHandler::HandleGetRecentlyBookmarked));
+}
+
 void RecentlyBookmarkedHandler::HandleGetRecentlyBookmarked(const Value*) {
   if (!model_) {
     model_ = dom_ui_->GetProfile()->GetBookmarkModel();
     model_->AddObserver(this);
   }
   // If the model is loaded, synchronously send the bookmarks down. Otherwise
   // when the model loads we'll send the bookmarks down.
   if (model_->IsLoaded())
     SendBookmarksToPage();
 }
@@ skipping 35 matching lines @@
                                                     BookmarkNode* node) {
   SendBookmarksToPage();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RecentlyClosedTabsHandler
 
 class RecentlyClosedTabsHandler : public DOMMessageHandler,
                                   public TabRestoreService::Observer {
  public:
-  explicit RecentlyClosedTabsHandler(DOMUI* dom_ui);
+  RecentlyClosedTabsHandler() : tab_restore_service_(NULL) { }
   virtual ~RecentlyClosedTabsHandler();
 
+  // DOMMessageHandler implementation.
+  virtual void RegisterMessages();
+
   // Callback for the "reopenTab" message. Rewrites the history of the
   // currently displayed tab to be the one in TabRestoreService with a
   // history of a session passed in through the content pointer.
   void HandleReopenTab(const Value* content);
 
   // Callback for the "getRecentlyClosedTabs" message.
   void HandleGetRecentlyClosedTabs(const Value* content);
 
   // Observer callback for TabRestoreService::Observer. Sends data on
   // recently closed tabs to the javascript side of this page to
   // display to the user.
   virtual void TabRestoreServiceChanged(TabRestoreService* service);
 
   // Observer callback to notice when our associated TabRestoreService
   // is destroyed.
   virtual void TabRestoreServiceDestroyed(TabRestoreService* service);
 
  private:
   // Converts a closed tab to the value sent down to the NTP. Returns true on
   // success, false if the value shouldn't be sent down.
   bool TabToValue(const TabRestoreService::Tab& tab,
                   DictionaryValue* dictionary);
 
   // Converts a closed window to the value sent down to the NTP. Returns true
   // on success, false if the value shouldn't be sent down.
   bool WindowToValue(const TabRestoreService::Window& window,
                      DictionaryValue* dictionary);
 
-  DOMUI* dom_ui_;
-
   // TabRestoreService that we are observing.
   TabRestoreService* tab_restore_service_;
 
   DISALLOW_COPY_AND_ASSIGN(RecentlyClosedTabsHandler);
 };
 
-RecentlyClosedTabsHandler::RecentlyClosedTabsHandler(DOMUI* dom_ui)
-    : DOMMessageHandler(dom_ui),
-      dom_ui_(dom_ui),
-      tab_restore_service_(NULL) {
-  dom_ui->RegisterMessageCallback("getRecentlyClosedTabs",
+void RecentlyClosedTabsHandler::RegisterMessages() {
+  dom_ui_->RegisterMessageCallback("getRecentlyClosedTabs",
       NewCallback(this,
                   &RecentlyClosedTabsHandler::HandleGetRecentlyClosedTabs));
-  dom_ui->RegisterMessageCallback("reopenTab",
+  dom_ui_->RegisterMessageCallback("reopenTab",
       NewCallback(this, &RecentlyClosedTabsHandler::HandleReopenTab));
 }
 
 RecentlyClosedTabsHandler::~RecentlyClosedTabsHandler() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 }
 
 void RecentlyClosedTabsHandler::HandleReopenTab(const Value* content) {
   Browser* browser = Browser::GetBrowserForController(
@@ skipping 119 matching lines @@
   dictionary->SetString(L"type", L"window");
   dictionary->Set(L"tabs", tab_values);
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // HistoryHandler
 
 class HistoryHandler : public DOMMessageHandler {
  public:
-  explicit HistoryHandler(DOMUI* dom_ui);
+  HistoryHandler() { }
+  virtual ~HistoryHandler() { }
+
+  // DOMMessageHandler implementation.
+  virtual void RegisterMessages();
 
   // Callback which navigates to the history page and performs a search.
   void HandleSearchHistoryPage(const Value* content);
 
  private:
-  DOMUI* dom_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryHandler);
 };
 
-HistoryHandler::HistoryHandler(DOMUI* dom_ui)
-    : DOMMessageHandler(dom_ui),
-      dom_ui_(dom_ui) {
-  dom_ui->RegisterMessageCallback("searchHistoryPage",
+void HistoryHandler::RegisterMessages() {
+  dom_ui_->RegisterMessageCallback("searchHistoryPage",
       NewCallback(this, &HistoryHandler::HandleSearchHistoryPage));
 }
 
 void HistoryHandler::HandleSearchHistoryPage(const Value* content) {
   if (content && content->GetType() == Value::TYPE_LIST) {
     const ListValue* list_value = static_cast<const ListValue*>(content);
     Value* list_member;
     if (list_value->Get(0, &list_member) &&
         list_member->GetType() == Value::TYPE_STRING) {
       const StringValue* string_value =
@@ skipping 15 matching lines @@
 // MetricsHandler
 
 // Let the page contents record UMA actions. Only use when you can't do it from
 // C++. For example, we currently use it to let the NTP log the postion of the
 // Most Visited or Bookmark the user clicked on, as we don't get that
 // information through RequestOpenURL. You will need to update the metrics
 // dashboard with the action names you use, as our processor won't catch that
 // information (treat it as RecordComputedMetrics)
 class MetricsHandler : public DOMMessageHandler {
  public:
-  explicit MetricsHandler(DOMUI* dom_ui);
-
+  MetricsHandler() { }
+  virtual ~MetricsHandler() { }
+  
+  // DOMMessageHandler implementation.
+  virtual void RegisterMessages();
+  
   // Callback which records a user action.
   void HandleMetrics(const Value* content);
 
  private:
-  DOMUI* dom_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsHandler);
 };
 
-MetricsHandler::MetricsHandler(DOMUI* dom_ui)
-    : DOMMessageHandler(dom_ui),
-      dom_ui_(dom_ui) {
-  dom_ui->RegisterMessageCallback("metrics",
+void MetricsHandler::RegisterMessages() {
+  dom_ui_->RegisterMessageCallback("metrics",
       NewCallback(this, &MetricsHandler::HandleMetrics));
 }
 
 void MetricsHandler::HandleMetrics(const Value* content) {
   if (content && content->GetType() == Value::TYPE_LIST) {
     const ListValue* list_value = static_cast<const ListValue*>(content);
     Value* list_member;
     if (list_value->Get(0, &list_member) &&
         list_member->GetType() == Value::TYPE_STRING) {
       const StringValue* string_value =
@@ skipping 42 matching lines @@
 
     g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(&chrome_url_data_manager,
             &ChromeURLDataManager::AddDataSource,
             html_source));
   } else {
 
     if (EnableNewNewTabPage()) {
       DownloadManager* dlm = GetProfile()->GetDownloadManager();
       DownloadsDOMHandler* downloads_handler =
-          new DownloadsDOMHandler(this, dlm);
+          new DownloadsDOMHandler(dlm);
+      downloads_handler->Attach(this);
       AddMessageHandler(downloads_handler);
       downloads_handler->Init();
 
-      AddMessageHandler(new ShownSectionsHandler(this));
+      AddMessageHandler((new ShownSectionsHandler())->Attach(this));
     }
 
+    AddMessageHandler((new TemplateURLHandler())->Attach(this));
+    AddMessageHandler((new MostVisitedHandler())->Attach(this));
+    AddMessageHandler((new RecentlyBookmarkedHandler())->Attach(this));
+    AddMessageHandler((new RecentlyClosedTabsHandler())->Attach(this));
+    AddMessageHandler((new HistoryHandler())->Attach(this));
+    AddMessageHandler((new MetricsHandler())->Attach(this));
     if (EnableWebResources())
-      AddMessageHandler(new TipsHandler(this));
+      AddMessageHandler((new TipsHandler())->Attach(this));
 
-    AddMessageHandler(new TemplateURLHandler(this));
-    AddMessageHandler(new MostVisitedHandler(this));
-    AddMessageHandler(new RecentlyBookmarkedHandler(this));
-    AddMessageHandler(new RecentlyClosedTabsHandler(this));
-    AddMessageHandler(new HistoryHandler(this));
-    AddMessageHandler(new MetricsHandler(this));
 #ifdef CHROME_PERSONALIZATION
     if (!Personalization::IsP13NDisabled(GetProfile())) {
       AddMessageHandler(Personalization::CreateNewTabPageHandler(this));
     }
 #endif
 
     // In testing mode there may not be an I/O thread.
     if (g_browser_process->io_thread()) {
       g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
           NewRunnableMethod(&chrome_url_data_manager,
@@ skipping 46 matching lines @@
 bool NewTabUI::EnableNewNewTabPage() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kNewNewTabPage);
 }
 
 bool NewTabUI::EnableWebResources() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kWebResources);
 }