Enable the NNTP by default...

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 185 matching lines @@
 
   virtual std::string GetMimeType(const std::string&) const {
     return "text/html";
   }
 
   // Setters and getters for first_view.
   static void set_first_view(bool first_view) { first_view_ = first_view; }
   static bool first_view() { return first_view_; }
 
  private:
-  // In case a file path to the new new tab page was provided this tries to load
+  // In case a file path to the new tab page was provided this tries to load
   // the file and returns the file content if successful. This returns an empty
   // string in case of failure.
-  static std::string GetNewNewTabFromCommandLine();
+  static std::string GetCustomNewTabPageFromCommandLine();
 
   // Whether this is the is the first viewing of the new tab page and
   // we think it is the user's startup page.
   static bool first_view_;
 
   // The user's profile.
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(NewTabHTMLSource);
 };
@@ skipping 127 matching lines @@
 
 #ifdef CHROME_PERSONALIZATION
   localized_strings.SetString(L"p13nsrc", Personalization::GetNewTabSource());
 #endif
 
   // In case we have the new new tab page enabled we first try to read the file
   // provided on the command line. If that fails we just get the resource from
   // the resource bundle.
   StringPiece new_tab_html;
   std::string new_tab_html_str;
-  if (NewTabUI::EnableNewNewTabPage()) {
-    new_tab_html_str = GetNewNewTabFromCommandLine();
+  new_tab_html_str = GetCustomNewTabPageFromCommandLine();
 
-    if (!new_tab_html_str.empty()) {
-      new_tab_html = StringPiece(new_tab_html_str);
-    } else {
-      // Use the new new tab page from the resource bundle.
-      new_tab_html = ResourceBundle::GetSharedInstance().GetRawDataResource(
-              IDR_NEW_NEW_TAB_HTML);
-    }
-  } else {
-    // Use the default new tab page resource.
+  if (!new_tab_html_str.empty()) {
+    new_tab_html = StringPiece(new_tab_html_str);
+  }
+
+  if (new_tab_html.empty()) {
     new_tab_html = ResourceBundle::GetSharedInstance().GetRawDataResource(
-        IDR_NEW_TAB_HTML);
+        NewTabUI::UseOldNewTabPage() ?
+            IDR_NEW_TAB_HTML :
+            IDR_NEW_NEW_TAB_HTML);
   }
 
   const std::string full_html = jstemplate_builder::GetTemplateHtml(
       new_tab_html, &localized_strings, "t" /* template root node id */);
 
   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);
 }
 
 // static
-std::string NewTabHTMLSource::GetNewNewTabFromCommandLine() {
+std::string NewTabHTMLSource::GetCustomNewTabPageFromCommandLine() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   const std::wstring file_path_wstring = command_line->GetSwitchValue(
-      switches::kNewNewTabPage);
+      switches::kNewTabPage);
 
 #if defined(OS_WIN)
   const FilePath::StringType file_path = file_path_wstring;
 #else
   const FilePath::StringType file_path = WideToASCII(file_path_wstring);
 #endif
 
   if (!file_path.empty()) {
     std::string file_contents;
     if (file_util::ReadFileToString(FilePath(file_path), &file_contents))
@@ skipping 589 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // RecentlyBookmarkedHandler
 
 class RecentlyBookmarkedHandler : public DOMMessageHandler,
                                   public BookmarkModelObserver {
  public:
   RecentlyBookmarkedHandler() : model_(NULL) {}
   virtual ~RecentlyBookmarkedHandler();
 
   // DOMMessageHandler implementation.
-  virtual void RegisterMessages();  
+  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 322 matching lines @@
 // 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:
   MetricsHandler() {}
   virtual ~MetricsHandler() {}
-  
+
   // DOMMessageHandler implementation.
   virtual void RegisterMessages();
-  
+
   // Callback which records a user action.
   void HandleMetrics(const Value* content);
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(MetricsHandler);
 };
 
 void MetricsHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback("metrics",
@@ skipping 48 matching lines @@
   if (GetProfile()->IsOffTheRecord()) {
     incognito_ = true;
 
     IncognitoTabHTMLSource* html_source = new IncognitoTabHTMLSource();
 
     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();
+    // This might be null in the case of running inside a unit test.
+    // TODO(arv): Fix unit tests to provide a working mock download manager.
+    if (dlm) {
       DownloadManager* dlm = GetProfile()->GetDownloadManager();
       DownloadsDOMHandler* downloads_handler =
           new DownloadsDOMHandler(dlm);
       downloads_handler->Attach(this);
       AddMessageHandler(downloads_handler);
       downloads_handler->Init();
-
-      AddMessageHandler((new ShownSectionsHandler())->Attach(this));
     }
 
-    AddMessageHandler((new TemplateURLHandler())->Attach(this));
+    AddMessageHandler((new ShownSectionsHandler())->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())->Attach(this));
 
+    if (UseOldNewTabPage()) {
+      AddMessageHandler((new TemplateURLHandler())->Attach(this));
+      AddMessageHandler((new RecentlyBookmarkedHandler())->Attach(this));
+      AddMessageHandler((new HistoryHandler())->Attach(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 25 matching lines @@
   if (NotificationType::THEME_INSTALLED == type) {
     CallJavascriptFunction(L"themeChanged");
   } else if (NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED) {
     if (GetProfile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar))
       CallJavascriptFunction(L"bookmarkBarAttached");
     else
       CallJavascriptFunction(L"bookmarkBarDetached");
   }
 }
 
-
 // static
 void NewTabUI::RegisterUserPrefs(PrefService* prefs) {
   MostVisitedHandler::RegisterUserPrefs(prefs);
+  ShownSectionsHandler::RegisterUserPrefs(prefs);
   if (NewTabUI::EnableWebResources())
     TipsHandler::RegisterUserPrefs(prefs);
-  if (NewTabUI::EnableNewNewTabPage())
-    ShownSectionsHandler::RegisterUserPrefs(prefs);
 }
 
 // static
-bool NewTabUI::EnableNewNewTabPage() {
+bool NewTabUI::UseOldNewTabPage() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  return command_line->HasSwitch(switches::kNewNewTabPage);
+  return command_line->HasSwitch(switches::kOldNewTabPage);
 }
 
 bool NewTabUI::EnableWebResources() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kWebResources);
 }
-