Improve New Tab Page load performance

chrome/browser/dom_ui/new_tab_ui.cc

 // Copyright (c) 2006-2009 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 <set>
 
@@ skipping 182 matching lines @@
   explicit NewTabHTMLSource(Profile* profile);
 
   // Called when the network layer has requested a resource underneath
   // the path we registered.
   virtual void StartDataRequest(const std::string& path, int request_id);
 
   virtual std::string GetMimeType(const std::string&) const {
     return "text/html";
   }
 
+  virtual MessageLoop* MessageLoopForRequestPath(const std::string& path)
+      const {
+    // NewTabHTMLSource does all of the operations that need to be on the
+    // UI thread from InitFullHTML, called by the constructor.  It is safe
+    // to call StartDataRequest from any thread, so return NULL.
+    return NULL;
+  }
+
   // 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_; }
 
   // Setters and getters for first_run.
   static void set_first_run(bool first_run) { first_run_ = first_run; }
   static bool first_run() { return first_run_; }
 
  private:
   // 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 GetCustomNewTabPageFromCommandLine();
 
+  // Populate full_html_.  This must be called from the UI thread because it
+  // involves profile access.
+  //
+  // A new NewTabHTMLSource object is used for each new tab page instance
+  // and each reload of an existing new tab page, so there is no concern
+  // about cached data becoming stale.
+  void InitFullHTML();
+
+  // The content to be served by StartDataRequest, stored by InitFullHTML.
+  std::string full_html_;
+
   // Whether this is the first viewing of the new tab page and
   // we think it is the user's startup page.
   static bool first_view_;
 
   // Whether this is the first run.
   static bool first_run_;
 
   // The user's profile.
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(NewTabHTMLSource);
 };
 
 bool NewTabHTMLSource::first_view_ = true;
 
 bool NewTabHTMLSource::first_run_ = true;
 
 NewTabHTMLSource::NewTabHTMLSource(Profile* profile)
     : DataSource(chrome::kChromeUINewTabHost, MessageLoop::current()),
       profile_(profile) {
+  InitFullHTML();
 }
 
 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;
   }
 
+  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::GetCustomNewTabPageFromCommandLine() {
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  const std::wstring file_path_wstring = command_line->GetSwitchValue(
+      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))
+      return file_contents;
+  }
+
+  return std::string();
+}
+
+void NewTabHTMLSource::InitFullHTML() {
   // Show the profile name in the title and most visited labels if the current
   // profile is not the default.
   std::wstring title;
   std::wstring most_visited;
   if (UserDataManager::Get()->is_current_profile_default()) {
     title = l10n_util::GetString(IDS_NEW_TAB_TITLE);
     most_visited = l10n_util::GetString(IDS_NEW_TAB_MOST_VISITED);
   } else {
     // Get the current profile name.
     std::wstring profile_name =
@@ skipping 118 matching lines @@
     new_tab_html = StringPiece(new_tab_html_str);
   }
 
   if (new_tab_html.empty()) {
     new_tab_html = ResourceBundle::GetSharedInstance().GetRawDataResource(
         NewTabUI::UseOldNewTabPage() ?
             IDR_NEW_TAB_HTML :
             IDR_NEW_NEW_TAB_HTML);
   }
 
-  std::string full_html(new_tab_html.data(), new_tab_html.size());
-  jstemplate_builder::AppendJsonHtml(&localized_strings, &full_html);
-  jstemplate_builder::AppendI18nTemplateSourceHtml(&full_html);
-  jstemplate_builder::AppendI18nTemplateProcessHtml(&full_html);
-
-  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::GetCustomNewTabPageFromCommandLine() {
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  const std::wstring file_path_wstring = command_line->GetSwitchValue(
-      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))
-      return file_contents;
-  }
-
-  return std::string();
+  full_html_.assign(new_tab_html.data(), new_tab_html.size());
+  jstemplate_builder::AppendJsonHtml(&localized_strings, &full_html_);
+  jstemplate_builder::AppendI18nTemplateSourceHtml(&full_html_);
+  jstemplate_builder::AppendI18nTemplateProcessHtml(&full_html_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // IncognitoTabHTMLSource
 
 class IncognitoTabHTMLSource : public ChromeURLDataManager::DataSource {
  public:
   // Creates our datasource and registers initial state of the bookmark bar.
   explicit IncognitoTabHTMLSource(bool bookmark_bar_attached);
 
   // Called when the network layer has requested a resource underneath
   // the path we registered.
   virtual void StartDataRequest(const std::string& path, int request_id);
 
   virtual std::string GetMimeType(const std::string&) const {
     return "text/html";
   }
 
+  virtual MessageLoop* MessageLoopForRequestPath(const std::string& path)
+      const {
+    // IncognitoTabHTMLSource does all of the operations that need to be on
+    // the UI thread from InitFullHTML, called by the constructor.  It is safe
+    // to call StartDataRequest from any thread, so return NULL.
+    return NULL;
+  }
+
  private:
+  // Populate full_html_.  This must be called from the UI thread because it
+  // involves profile access.
+  //
+  // A new IncognitoTabHTMLSource object is used for each incognito tab page
+  // instance and each reload of an existing incognito tab page, so there is
+  // no concern about cached data becoming stale.
+  void InitFullHTML();
+
+  // The content to be served by StartDataRequest, stored by InitFullHTML.
+  std::string full_html_;
+
   bool bookmark_bar_attached_;
 
   DISALLOW_COPY_AND_ASSIGN(IncognitoTabHTMLSource);
 };
 
 IncognitoTabHTMLSource::IncognitoTabHTMLSource(bool bookmark_bar_attached)
     : DataSource(chrome::kChromeUINewTabHost, MessageLoop::current()),
       bookmark_bar_attached_(bookmark_bar_attached) {
+  InitFullHTML();
 }
 
 void IncognitoTabHTMLSource::StartDataRequest(const std::string& path,
                                               int request_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);
+}
+
+void IncognitoTabHTMLSource::InitFullHTML() {
   DictionaryValue localized_strings;
   localized_strings.SetString(L"title",
       l10n_util::GetString(IDS_NEW_TAB_TITLE));
   localized_strings.SetString(L"content",
       l10n_util::GetStringF(IDS_NEW_TAB_OTR_MESSAGE,
           l10n_util::GetString(IDS_LEARN_MORE_INCOGNITO_URL)));
   localized_strings.SetString(L"bookmarkbarattached",
       bookmark_bar_attached_ ? "true" : "false");
 
   SetFontAndTextDirection(&localized_strings);
 
   static const StringPiece incognito_tab_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_INCOGNITO_TAB_HTML));
 
-  const std::string full_html = jstemplate_builder::GetI18nTemplateHtml(
-      incognito_tab_html, &localized_strings);
-
-  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);
+  full_html_ = jstemplate_builder::GetI18nTemplateHtml(incognito_tab_html,
+                                                       &localized_strings);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // MostVisitedPage
 
 // This struct is used when getting the prepopulated pages in case the user
 // hasn't filled up his most visited pages.
 struct MostVisitedPage {
   std::wstring title;
   GURL url;
@@ skipping 1167 matching lines @@
 bool NewTabUI::WebResourcesEnabled() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   return !command_line->HasSwitch(switches::kDisableWebResources);
 }
 
 // static
 bool NewTabUI::FirstRunDisabled() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kDisableNewTabFirstRun);
 }