Enable history and downloads by default, port NewTabUI from DOMUIHost to DOMU...

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 "base/histogram.h"
 #include "base/string_piece.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/dom_ui/dom_ui_contents.h"
 #if defined(OS_WIN)
 // TODO(port): include this once history is converted to HTML
-#include "chrome/browser/history_tab_ui.h"
+#include "chrome/browser/dom_ui/history_ui.h"
 #endif
 #include "chrome/browser/history/page_usage_data.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/user_data_manager.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/resource_bundle.h"
 #ifdef CHROME_PERSONALIZATION
 #include "chrome/personalization/personalization.h"
 #endif
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 
-// The URL scheme used for the new tab.
-static const char kNewTabUIScheme[] = "chrome-internal";
+// NewTabUI is accessible from chrome-ui://newtab.
+static const char kNewTabHost[] = "newtab";
 
 // The number of most visited pages we show.
 const int kMostVisitedPages = 9;
 
 // The number of days of history we consider for most visited entries.
 const int kMostVisitedScope = 90;
 
 // The number of recent bookmarks we show.
 static const int kRecentBookmarks = 9;
 
@@ skipping 117 matching lines @@
   dictionary->SetString(L"title", title_to_set);
   dictionary->SetString(L"direction", direction);
 }
 
 }  // end anonymous namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabHTMLSource
 
 NewTabHTMLSource::NewTabHTMLSource()
-    : DataSource("new-tab", MessageLoop::current()) {
+    : DataSource(kNewTabHost, MessageLoop::current()) {
 }
 
 void NewTabHTMLSource::StartDataRequest(const std::string& path,
                                         int request_id) {
   if (!path.empty()) {
     // A path under new-tab was requested; it's likely a bad relative
     // URL from the new tab page, but in any case it's an error.
     NOTREACHED();
     return;
   }
@@ skipping 91 matching lines @@
   scoped_refptr<RefCountedBytes> html_bytes(new RefCountedBytes);
   html_bytes->data.resize(full_html.size());
   std::copy(full_html.begin(), full_html.end(), html_bytes->data.begin());
 
   SendResponse(request_id, html_bytes);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // MostVisitedHandler
 
-MostVisitedHandler::MostVisitedHandler(DOMUIHost* dom_ui_host)
-    : dom_ui_host_(dom_ui_host) {
+MostVisitedHandler::MostVisitedHandler(DOMUI* dom_ui)
+    : DOMMessageHandler(dom_ui),
+      dom_ui_(dom_ui) {
   // Register ourselves as the handler for the "mostvisited" message from
   // Javascript.
-  dom_ui_host_->RegisterMessageCallback("getMostVisited",
+  dom_ui_->RegisterMessageCallback("getMostVisited",
       NewCallback(this, &MostVisitedHandler::HandleGetMostVisited));
 
   // Set up our sources for thumbnail and favicon data.
   // Ownership is passed to the ChromeURLDataManager.
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(&chrome_url_data_manager,
                         &ChromeURLDataManager::AddDataSource,
-                        new ThumbnailSource(dom_ui_host->profile())));
+                        new ThumbnailSource(dom_ui->get_profile())));
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(&chrome_url_data_manager,
                         &ChromeURLDataManager::AddDataSource,
-                        new FavIconSource(dom_ui_host->profile())));
+                        new FavIconSource(dom_ui->get_profile())));
 
   // Get notifications when history is cleared.
   NotificationService* service = NotificationService::current();
   service->AddObserver(this, NotificationType::HISTORY_URLS_DELETED,
-                       Source<Profile>(dom_ui_host_->profile()));
+                       Source<Profile>(dom_ui_->get_profile()));
 }
 
 MostVisitedHandler::~MostVisitedHandler() {
   NotificationService* service = NotificationService::current();
   service->RemoveObserver(this, NotificationType::HISTORY_URLS_DELETED,
-                          Source<Profile>(dom_ui_host_->profile()));
+                          Source<Profile>(dom_ui_->get_profile()));
 }
 
 void MostVisitedHandler::HandleGetMostVisited(const Value* value) {
   HistoryService* hs =
-      dom_ui_host_->profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
+      dom_ui_->get_profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   hs->QuerySegmentUsageSince(
       &cancelable_consumer_,
       base::Time::Now() - base::TimeDelta::FromDays(kMostVisitedScope),
       NewCallback(this, &MostVisitedHandler::OnSegmentUsageAvailable));
 }
 
 void MostVisitedHandler::OnSegmentUsageAvailable(
     CancelableRequestProvider::Handle handle,
     std::vector<PageUsageData*>* data) {
   most_visited_urls_.clear();
 
   ListValue pages_value;
   const size_t count = std::min<size_t>(kMostVisitedPages, data->size());
   for (size_t i = 0; i < count; ++i) {
     const PageUsageData& page = *(*data)[i];
     DictionaryValue* page_value = new DictionaryValue;
     SetURLTitleAndDirection(page_value, page.GetTitle(), page.GetURL());
     pages_value.Append(page_value);
     most_visited_urls_.push_back(page.GetURL());
   }
-  dom_ui_host_->CallJavascriptFunction(L"mostVisitedPages", pages_value);
+  dom_ui_->CallJavascriptFunction(L"mostVisitedPages", pages_value);
 }
 
 void MostVisitedHandler::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   if (type != NotificationType::HISTORY_URLS_DELETED) {
     NOTREACHED();
     return;
   }
 
   // Some URLs were deleted from history.  Reload the most visited list.
   HandleGetMostVisited(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TemplateURLHandler
 
-TemplateURLHandler::TemplateURLHandler(DOMUIHost* dom_ui_host)
-    : dom_ui_host_(dom_ui_host), template_url_model_(NULL) {
-  dom_ui_host->RegisterMessageCallback("getMostSearched",
+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_host->RegisterMessageCallback("doSearch",
+  dom_ui->RegisterMessageCallback("doSearch",
       NewCallback(this, &TemplateURLHandler::HandleDoSearch));
 }
 
 TemplateURLHandler::~TemplateURLHandler() {
   if (template_url_model_)
     template_url_model_->RemoveObserver(this);
 }
 
 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_host_->profile()->GetTemplateURLModel();
+    template_url_model_ = dom_ui_->get_profile()->GetTemplateURLModel();
     template_url_model_->AddObserver(this);
   }
   if (template_url_model_->loaded()) {
     OnTemplateURLModelChanged();
   } else {
     template_url_model_->Load();
   }
 }
 
 // A helper function for sorting TemplateURLs where the most used ones show up
@@ skipping 36 matching lines @@
   const TemplateURLRef* url_ref = template_url->url();
   if (!url_ref || !url_ref->SupportsReplacement()) {
     NOTREACHED();
     return;
   }
   GURL url = url_ref->ReplaceSearchTerms(*template_url, search,
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
 
   if (url.is_valid()) {
     // Load the URL.
-    dom_ui_host_->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::LINK);
+    dom_ui_->get_contents()->OpenURL(url, GURL(), CURRENT_TAB,
+                                     PageTransition::LINK);
 
     // Record the user action
     std::vector<const TemplateURL*> urls =
         template_url_model_->GetTemplateURLs();
     sort(urls.begin(), urls.end(), TemplateURLSortByUsage);
     ListValue urls_value;
     int item_number = 0;
     for (size_t i = 0;
          i < std::min<size_t>(urls.size(), kSearchURLs); ++i) {
       if (urls[i]->usage_count() == 0)
         break;  // The remainder would be no good.
 
       const TemplateURLRef* urlref = urls[i]->url();
       if (!urlref)
         continue;
 
       if (urls[i] == template_url) {
         UserMetrics::RecordComputedAction(
             StringPrintf(L"NTP_SearchURL%d", item_number),
-            dom_ui_host_->profile());
+            dom_ui_->get_profile());
         break;
       }
 
       item_number++;
     }
   }
 }
 
 void TemplateURLHandler::OnTemplateURLModelChanged() {
   // We've loaded some template URLs.  Send them to the page.
@@ skipping 11 matching lines @@
     entry_value->SetString(L"short_name", urls[i]->short_name());
     entry_value->SetString(L"keyword", urls[i]->keyword());
 
     const GURL& url = urls[i]->GetFavIconURL();
     if (url.is_valid())
      entry_value->SetString(L"favIconURL", UTF8ToWide(url.spec()));
 
     urls_value.Append(entry_value);
   }
   UMA_HISTOGRAM_COUNTS("NewTabPage.SearchURLs.Total", urls_value.GetSize());
-  dom_ui_host_->CallJavascriptFunction(L"searchURLs", urls_value);
+  dom_ui_->CallJavascriptFunction(L"searchURLs", urls_value);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RecentlyBookmarkedHandler
 
-RecentlyBookmarkedHandler::RecentlyBookmarkedHandler(DOMUIHost* dom_ui_host)
-    : dom_ui_host_(dom_ui_host),
+RecentlyBookmarkedHandler::RecentlyBookmarkedHandler(DOMUI* dom_ui)
+    : DOMMessageHandler(dom_ui),
+      dom_ui_(dom_ui),
       model_(NULL) {
-  dom_ui_host->RegisterMessageCallback("getRecentlyBookmarked",
+  dom_ui->RegisterMessageCallback("getRecentlyBookmarked",
       NewCallback(this,
                   &RecentlyBookmarkedHandler::HandleGetRecentlyBookmarked));
 }
 
 RecentlyBookmarkedHandler::~RecentlyBookmarkedHandler() {
   if (model_)
     model_->RemoveObserver(this);
 }
 
 void RecentlyBookmarkedHandler::HandleGetRecentlyBookmarked(const Value*) {
   if (!model_) {
-    model_ = dom_ui_host_->profile()->GetBookmarkModel();
+    model_ = dom_ui_->get_profile()->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();
 }
 
 void RecentlyBookmarkedHandler::SendBookmarksToPage() {
   std::vector<BookmarkNode*> recently_bookmarked;
   bookmark_utils::GetMostRecentlyAddedEntries(
       model_, kRecentBookmarks, &recently_bookmarked);
   ListValue list_value;
   for (size_t i = 0; i < recently_bookmarked.size(); ++i) {
     BookmarkNode* node = recently_bookmarked[i];
     DictionaryValue* entry_value = new DictionaryValue;
     SetURLTitleAndDirection(entry_value, node->GetTitle(), node->GetURL());
     list_value.Append(entry_value);
   }
-  dom_ui_host_->CallJavascriptFunction(L"recentlyBookmarked", list_value);
+  dom_ui_->CallJavascriptFunction(L"recentlyBookmarked", list_value);
 }
 
 void RecentlyBookmarkedHandler::Loaded(BookmarkModel* model) {
   SendBookmarksToPage();
 }
 
 void RecentlyBookmarkedHandler::BookmarkNodeAdded(BookmarkModel* model,
                                                   BookmarkNode* parent,
                                                   int index) {
   SendBookmarksToPage();
 }
 
 void RecentlyBookmarkedHandler::BookmarkNodeRemoved(BookmarkModel* model,
                                                     BookmarkNode* parent,
                                                     int index) {
   SendBookmarksToPage();
 }
 
 void RecentlyBookmarkedHandler::BookmarkNodeChanged(BookmarkModel* model,
                                                     BookmarkNode* node) {
   SendBookmarksToPage();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RecentlyClosedTabsHandler
 
-RecentlyClosedTabsHandler::RecentlyClosedTabsHandler(DOMUIHost* dom_ui_host)
-    : dom_ui_host_(dom_ui_host),
+RecentlyClosedTabsHandler::RecentlyClosedTabsHandler(DOMUI* dom_ui)
+    : DOMMessageHandler(dom_ui),
+      dom_ui_(dom_ui),
       tab_restore_service_(NULL) {
-  dom_ui_host->RegisterMessageCallback("getRecentlyClosedTabs",
+  dom_ui->RegisterMessageCallback("getRecentlyClosedTabs",
       NewCallback(this,
                   &RecentlyClosedTabsHandler::HandleGetRecentlyClosedTabs));
-  dom_ui_host->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) {
-  NavigationController* controller = dom_ui_host_->controller();
+  NavigationController* controller = dom_ui_->get_contents()->controller();
   Browser* browser = Browser::GetBrowserForController(
       controller, NULL);
   if (!browser)
     return;
 
   // Extract the integer value of the tab session to restore from the
   // incoming string array. This will be greatly simplified when
   // DOMUIBindings::send() is generalized to all data types instead of
   // silently failing when passed anything other then an array of
   // strings.
@@ skipping 12 matching lines @@
         // The current tab has been nuked at this point; don't touch any member
         // variables.
       }
     }
   }
 }
 
 void RecentlyClosedTabsHandler::HandleGetRecentlyClosedTabs(
     const Value* content) {
   if (!tab_restore_service_) {
-    tab_restore_service_ = dom_ui_host_->profile()->GetTabRestoreService();
+    tab_restore_service_ = dom_ui_->get_profile()->GetTabRestoreService();
 
     // GetTabRestoreService() can return NULL (i.e., when in Off the
     // Record mode)
     if (tab_restore_service_) {
       // This does nothing if the tabs have already been loaded or they
       // shouldn't be loaded.
       tab_restore_service_->LoadTabsFromLastSession();
 
       tab_restore_service_->AddObserver(this);
     }
@@ skipping 21 matching lines @@
         (entry->type == TabRestoreService::WINDOW &&
          WindowToValue(*static_cast<TabRestoreService::Window*>(entry),
                        value))) {
       value->SetInteger(L"sessionId", entry->id);
       list_value.Append(value);
       added_count++;
     } else {
       delete value;
     }
   }
-  dom_ui_host_->CallJavascriptFunction(L"recentlyClosedTabs", list_value);
+  dom_ui_->CallJavascriptFunction(L"recentlyClosedTabs", list_value);
 }
 
 void RecentlyClosedTabsHandler::TabRestoreServiceDestroyed(
     TabRestoreService* service) {
   tab_restore_service_ = NULL;
 }
 
 bool RecentlyClosedTabsHandler::TabToValue(
     const TabRestoreService::Tab& tab,
     DictionaryValue* dictionary) {
   if (tab.navigations.empty())
     return false;
 
   const TabNavigation& current_navigation =
       tab.navigations.at(tab.current_navigation_index);
-  if (current_navigation.url() == NewTabUIURL())
+  if (current_navigation.url() == NewTabUI::GetBaseURL())
     return false;
 
   SetURLTitleAndDirection(dictionary, current_navigation.title(),
                           current_navigation.url());
   dictionary->SetString(L"type", L"tab");
   return true;
 }
 
 bool RecentlyClosedTabsHandler::WindowToValue(
     const TabRestoreService::Window& window,
@@ skipping 17 matching lines @@
   }
 
   dictionary->SetString(L"type", L"window");
   dictionary->Set(L"tabs", tab_values);
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // HistoryHandler
 
-HistoryHandler::HistoryHandler(DOMUIHost* dom_ui_host)
-    : dom_ui_host_(dom_ui_host) {
-  dom_ui_host->RegisterMessageCallback("showHistoryPage",
+HistoryHandler::HistoryHandler(DOMUI* dom_ui)
+    : DOMMessageHandler(dom_ui),
+      dom_ui_(dom_ui) {
+  dom_ui->RegisterMessageCallback("showHistoryPage",
       NewCallback(this, &HistoryHandler::HandleShowHistoryPage));
-  dom_ui_host->RegisterMessageCallback("searchHistoryPage",
+  dom_ui->RegisterMessageCallback("searchHistoryPage",
       NewCallback(this, &HistoryHandler::HandleSearchHistoryPage));
 }
 
 void HistoryHandler::HandleShowHistoryPage(const Value*) {
-  NavigationController* controller = dom_ui_host_->controller();
+  NavigationController* controller = dom_ui_->get_contents()->controller();
   if (controller) {
 #if defined(OS_WIN)
 // TODO(port): include this once history is converted to HTML
-    controller->LoadURL(HistoryTabUI::GetURL(), GURL(), PageTransition::LINK);
+    controller->LoadURL(HistoryUI::GetBaseURL(), GURL(), PageTransition::LINK);
     UserMetrics::RecordAction(L"NTP_ShowHistory",
-        dom_ui_host_->profile());
+        dom_ui_->get_profile());
 #else
     NOTIMPLEMENTED();
 #endif
   }
 }
 
 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 =
           static_cast<const StringValue*>(list_member);
       std::wstring wstring_value;
       if (string_value->GetAsString(&wstring_value)) {
         UserMetrics::RecordAction(L"NTP_SearchHistory",
-            dom_ui_host_->profile());
+            dom_ui_->get_profile());
 
 #if defined(OS_WIN)
 // TODO(port): include this once history is converted to HTML
-        NavigationController* controller = dom_ui_host_->controller();
+        NavigationController* controller =
+            dom_ui_->get_contents()->controller();
         controller->LoadURL(
-            HistoryTabUI::GetHistoryURLWithSearchText(wstring_value),
+            HistoryUI::GetHistoryURLWithSearchText(wstring_value),
             GURL(),
             PageTransition::LINK);
 #else
         NOTIMPLEMENTED();
 #endif
       }
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // MetricsHandler
 
-MetricsHandler::MetricsHandler(DOMUIHost* dom_ui_host)
-    : dom_ui_host_(dom_ui_host) {
-  dom_ui_host->RegisterMessageCallback("metrics",
+MetricsHandler::MetricsHandler(DOMUI* dom_ui)
+    : DOMMessageHandler(dom_ui),
+      dom_ui_(dom_ui) {
+  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 =
           static_cast<const StringValue*>(list_member);
       std::wstring wstring_value;
       if (string_value->GetAsString(&wstring_value)) {
         UserMetrics::RecordComputedAction(wstring_value,
-            dom_ui_host_->profile());
+            dom_ui_->get_profile());
       }
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabUIContents
 
-// This is the top-level URL handler for chrome-internal: URLs, and exposed in
-// our header file.
-bool NewTabUIHandleURL(GURL* url,
-                       TabContentsType* result_type) {
-  if (!url->SchemeIs(kNewTabUIScheme))
-    return false;
-
-  *result_type = TAB_CONTENTS_NEW_TAB_UI;
-  *url = GURL(DOMUIContents::GetScheme() + "://new-tab/");
-
-  return true;
-}
-
-GURL NewTabUIURL() {
-  std::string url(kNewTabUIScheme);
-  url += ":";
-  return GURL(url);
-}
-
-NewTabUIContents::NewTabUIContents(Profile* profile,
-    SiteInstance* instance, RenderViewHostFactory* render_view_factory) :
-    DOMUIHost(profile, instance, render_view_factory),
+NewTabUI::NewTabUI(DOMUIContents* contents) :
+    DOMUI(contents),
     motd_message_id_(0),
     incognito_(false),
     most_visited_handler_(NULL) {
-  set_type(TAB_CONTENTS_NEW_TAB_UI);
-
   // Show profile name in the title if the current profile is not the default.
   std::wstring title;
   if (UserDataManager::Get()->is_current_profile_default()) {
     title = l10n_util::GetString(IDS_NEW_TAB_TITLE);
   } else {
     title = l10n_util::GetStringF(
         IDS_NEW_TAB_TITLE_WITH_PROFILE_NAME,
         UserDataManager::Get()->current_profile_name());
   }
   set_forced_title(title);
 
-  if (profile->IsOffTheRecord())
+  if (get_profile()->IsOffTheRecord())
     incognito_ = true;
 
   if (NewTabHTMLSource::first_view() &&
-      (profile->GetPrefs()->GetInteger(prefs::kRestoreOnStartup) != 0 ||
-       !profile->GetPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage))
+      (get_profile()->GetPrefs()->GetInteger(prefs::kRestoreOnStartup) != 0 ||
+       !get_profile()->GetPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage))
      ) {
     NewTabHTMLSource::set_first_view(false);
   }
 
-  render_view_host()->set_paint_observer(new PaintTimer);
+  contents->render_view_host()->set_paint_observer(new PaintTimer);
 }
 
-void NewTabUIContents::AttachMessageHandlers() {
+void NewTabUI::Init() {
   // Regretfully, DataSources are global, instead of
   // per-TabContents. Because of the motd_message_id_ member, each
   // NewTabUIContents instance could theoretically have a different
   // message. Moving this from the constructor to here means that we
   // reconnect this source each time we reload so we should no longer
   // have the bug where we open a normal new tab page (no motd), open
   // another OTR new tab page (blurb motd describing what 'incognito'
   // means), refresh the normal new page (which now displays the
   // incognito blurb because that was the last NewTabHTMLSource hooked
   // up).
@@ skipping 21 matching lines @@
 
     NewTabHTMLSource* html_source = new NewTabHTMLSource();
 
     g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(&chrome_url_data_manager,
             &ChromeURLDataManager::AddDataSource,
             html_source));
   }
 }
 
-bool NewTabUIContents::NavigateToPendingEntry(bool reload) {
-  const bool result = WebContents::NavigateToPendingEntry(reload);
-  controller()->GetPendingEntry()->set_title(forced_title_);
-  return result;
+// static
+GURL NewTabUI::GetBaseURL() {
+  std::string url = DOMUIContents::GetScheme();
+  url += "://";
+  url += kNewTabHost;
+  return GURL(url);
 }
 
-const std::wstring& NewTabUIContents::GetTitle() const {
-  if (!forced_title_.empty())
-    return forced_title_;
-  return WebContents::GetTitle();
+void NewTabUI::SetInitialFocus() {
+  if (get_contents()->delegate())
+    get_contents()->delegate()->SetFocusToLocationBar();
 }
 
-void NewTabUIContents::SetInitialFocus() {
-  if (delegate())
-    delegate()->SetFocusToLocationBar();
-}
-
-bool NewTabUIContents::SupportsURL(GURL* url) {
-  if (url->SchemeIs("javascript"))
-    return true;
-  return DOMUIHost::SupportsURL(url);
-}
-
-void NewTabUIContents::RequestOpenURL(const GURL& url,
-                                      const GURL& /*referrer*/,
-                                      WindowOpenDisposition disposition) {
+void NewTabUI::RequestOpenURL(const GURL& url,
+                              const GURL&,
+                              WindowOpenDisposition disposition) {
   // The user opened a URL on the page (including "open in new window").
   // We count all such clicks as AUTO_BOOKMARK, which increments the site's
   // visit count (which is used for ranking the most visited entries).
-  // Note this means we're including clicks on not only most visited thumbnails,
-  // but also clicks on recently bookmarked.
-  OpenURL(url, GURL(), disposition, PageTransition::AUTO_BOOKMARK);
+  // Note this means we're including clicks on not only most visited
+  // thumbnails, but also clicks on recently bookmarked.
+  get_contents()->OpenURL(url, GURL(), disposition,
+                          PageTransition::AUTO_BOOKMARK);
 }