Simplify WebUI data sources. Currently WebUI data sources implement a URLDataSourceDelegate interfa…

chrome/browser/ui/webui/about_ui.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/about_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 19 matching lines @@
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/memory_details.h"
 #include "chrome/browser/net/predictor.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser_dialogs.h"
-#include "chrome/browser/ui/webui/chrome_url_data_manager.h"
+#include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/process_type.h"
@@ skipping 57 matching lines @@
 std::string GetAboutMemoryRedirectResponse(Profile* profile) {
   return StringPrintf("<meta http-equiv=\"refresh\" content=\"0;%s\">",
                       chrome::kChromeUIMemoryRedirectURL);
 }
 
 // Handling about:memory is complicated enough to encapsulate its related
 // methods into a single class. The user should create it (on the heap) and call
 // its |StartFetch()| method.
 class AboutMemoryHandler : public MemoryDetails {
  public:
-  AboutMemoryHandler(const base::WeakPtr<AboutUIHTMLSource>& source,
-                     int request_id)
-      : source_(source),
-        request_id_(request_id) {
+  explicit AboutMemoryHandler(
+      const content::URLDataSource::GotDataCallback& callback)
+      : callback_(callback) {
   }
 
   virtual void OnDetailsAvailable() OVERRIDE;
 
  private:
   ~AboutMemoryHandler() {}
 
   void BindProcessMetrics(DictionaryValue* data,
                           ProcessMemoryInformation* info);
   void AppendProcess(ListValue* child_data, ProcessMemoryInformation* info);
 
-  base::WeakPtr<AboutUIHTMLSource> source_;
-  int request_id_;
+  content::URLDataSource::GotDataCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutMemoryHandler);
 };
 
 #if defined(OS_CHROMEOS)
 class ChromeOSTermsHandler
     : public base::RefCountedThreadSafe<ChromeOSTermsHandler> {
  public:
-  static void Start(const base::WeakPtr<AboutUIHTMLSource>& source,
-                    const std::string& path,
-                    int request_id) {
+  static void Start(const std::string& path,
+                    const content::URLDataSource::GotDataCallback& callback) {
     scoped_refptr<ChromeOSTermsHandler> handler(
-        new ChromeOSTermsHandler(source, path, request_id));
+        new ChromeOSTermsHandler(path, callback));
     handler->StartOnUIThread();
   }
 
  private:
   friend class base::RefCountedThreadSafe<ChromeOSTermsHandler>;
 
-  ChromeOSTermsHandler(const base::WeakPtr<AboutUIHTMLSource>& source,
-                       const std::string& path,
-                       int request_id)
-    : source_(source),
-      path_(path),
-      request_id_(request_id),
+  ChromeOSTermsHandler(const std::string& path,
+                       const content::URLDataSource::GotDataCallback& callback)
+    : path_(path),
+      callback_(callback),
       // Previously we were using "initial locale" http://crbug.com/145142
       locale_(g_browser_process->GetApplicationLocale()) {
   }
 
   ~ChromeOSTermsHandler() {}
 
   void StartOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
@@ skipping 27 matching lines @@
         }
       }
     }
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&ChromeOSTermsHandler::ResponseOnUIThread, this));
   }
 
   void ResponseOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!source_)
-      return;
-
     // If we fail to load Chrome OS EULA from disk, load it from resources.
     // Do nothing if OEM EULA load failed.
     if (contents_.empty() && path_ != chrome::kOemEulaURLPath)
       contents_ = l10n_util::GetStringUTF8(IDS_TERMS_HTML);
-    source_->FinishDataRequest(contents_, request_id_);
+    callback_.Run(base::RefCountedString::TakeString(&contents_));
   }
 
-  // Where the results are fed to.
-  base::WeakPtr<AboutUIHTMLSource> source_;
-
   // Path in the URL.
   std::string path_;
 
-  // ID identifying the request.
-  int request_id_;
+  // Callback to run with the response.
+  content::URLDataSource::GotDataCallback callback_;
 
   // Locale of the EULA.
   std::string locale_;
 
   // EULA contents that was loaded from file.
   std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeOSTermsHandler);
 };
 
@@ skipping 261 matching lines @@
   AppendFooter(&output);
   return output;
 }
 
 #endif  // USE_ASH
 
 // AboutDnsHandler bounces the request back to the IO thread to collect
 // the DNS information.
 class AboutDnsHandler : public base::RefCountedThreadSafe<AboutDnsHandler> {
  public:
-  static void Start(const base::WeakPtr<AboutUIHTMLSource>& source,
-                    int request_id) {
+  static void Start(Profile* profile,
+                    const content::URLDataSource::GotDataCallback& callback) {
     scoped_refptr<AboutDnsHandler> handler(
-        new AboutDnsHandler(source, request_id));
+        new AboutDnsHandler(profile, callback));
     handler->StartOnUIThread();
   }
 
  private:
   friend class base::RefCountedThreadSafe<AboutDnsHandler>;
 
-  AboutDnsHandler(const base::WeakPtr<AboutUIHTMLSource>& source,
-                  int request_id)
-      : source_(source),
-        request_id_(request_id) {
+  AboutDnsHandler(Profile* profile,
+                  const content::URLDataSource::GotDataCallback& callback)
+      : profile_(profile),
+        callback_(callback) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   virtual ~AboutDnsHandler() {}
 
   // Calls FinishOnUIThread() on completion.
   void StartOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    chrome_browser_net::Predictor* predictor =
-        source_->profile()->GetNetworkPredictor();
+    chrome_browser_net::Predictor* predictor = profile_->GetNetworkPredictor();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&AboutDnsHandler::StartOnIOThread, this, predictor));
   }
 
   void StartOnIOThread(chrome_browser_net::Predictor* predictor) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     std::string data;
     AppendHeader(&data, 0, "About DNS");
     AppendBody(&data);
     chrome_browser_net::Predictor::PredictorGetHtmlInfo(predictor, &data);
     AppendFooter(&data);
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&AboutDnsHandler::FinishOnUIThread, this, data));
   }
 
   void FinishOnUIThread(const std::string& data) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (source_)
-      source_->FinishDataRequest(data, request_id_);
+    std::string data_copy(data);
+    callback_.Run(base::RefCountedString::TakeString(&data_copy));
   }
 
-  // Where the results are fed to.
-  base::WeakPtr<AboutUIHTMLSource> source_;
+  Profile* profile_;
 
-  // ID identifying the request.
-  int request_id_;
+  // Callback to run with the response.
+  content::URLDataSource::GotDataCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutDnsHandler);
 };
 
-void FinishMemoryDataRequest(const std::string& path,
-                             AboutUIHTMLSource* source,
-                             int request_id) {
+void FinishMemoryDataRequest(
+    const std::string& path,
+    AboutUIHTMLSource* source,
+    const content::URLDataSource::GotDataCallback& callback) {
   if (path == kStringsJsPath) {
     // The AboutMemoryHandler cleans itself up, but |StartFetch()| will want
     // the refcount to be greater than 0.
-    scoped_refptr<AboutMemoryHandler>
-        handler(new AboutMemoryHandler(source->AsWeakPtr(), request_id));
+    scoped_refptr<AboutMemoryHandler> handler(new AboutMemoryHandler(callback));
     // TODO(jamescook): Maybe this shouldn't update UMA?
     handler->StartFetch(MemoryDetails::UPDATE_USER_METRICS);
   } else {
     source->FinishDataRequest(
         ResourceBundle::GetSharedInstance().GetRawDataResource(
             path == kMemoryJsPath ? IDR_ABOUT_MEMORY_JS :
-            IDR_ABOUT_MEMORY_HTML).as_string(), request_id);
+            IDR_ABOUT_MEMORY_HTML).as_string(), callback);
   }
 }
 
 // Handler for filling in the "about:stats" page, as called by the browser's
 // About handler processing.
 // |query| is roughly the query string of the about:stats URL.
 // Returns a string containing the HTML to render for the about:stats page.
 // Conditional Output:
 //      if |query| is "json", returns a JSON format of all counters.
 //      if |query| is "raw", returns plain text of counter deltas.
@@ skipping 274 matching lines @@
   if (info->is_diagnostics)
     child_label.append(" (diagnostics)");
   child->SetString("child_name", child_label);
   ListValue* titles = new ListValue();
   child->Set("titles", titles);
   for (size_t i = 0; i < info->titles.size(); ++i)
     titles->Append(new StringValue(info->titles[i]));
 }
 
 void AboutMemoryHandler::OnDetailsAvailable() {
-  if (!source_)
-    return;
-
   // the root of the JSON hierarchy for about:memory jstemplate
   scoped_ptr<DictionaryValue> root(new DictionaryValue);
   ListValue* browsers = new ListValue();
   root->Set("browsers", browsers);
 
   const std::vector<ProcessData>& browser_processes = processes();
 
   // Aggregate per-process data into browser summary data.
   string16 log_string;
   for (size_t index = 0; index < browser_processes.size(); index++) {
@@ skipping 54 matching lines @@
       AppendProcess(child_data, &process.processes[index]);
   }
 
   root->SetBoolean("show_other_browsers",
       browser_defaults::kShowOtherBrowsersInAboutMemory);
 
   DictionaryValue load_time_data;
   load_time_data.SetString(
       "summary_desc",
       l10n_util::GetStringUTF16(IDS_MEMORY_USAGE_SUMMARY_DESC));
-  URLDataSource::SetFontAndTextDirection(&load_time_data);
+  web_ui_util::SetFontAndTextDirection(&load_time_data);
   load_time_data.Set("jstemplateData", root.release());
 
   jstemplate_builder::UseVersion2 version2;
   std::string data;
   jstemplate_builder::AppendJsonJS(&load_time_data, &data);
-  source_->FinishDataRequest(data, request_id_);
+  callback_.Run(base::RefCountedString::TakeString(&data));
 }
 
 }  // namespace
 
 // AboutUIHTMLSource ----------------------------------------------------------
 
 AboutUIHTMLSource::AboutUIHTMLSource(const std::string& source_name,
                                      Profile* profile)
     : source_name_(source_name),
       profile_(profile) {}
 
 AboutUIHTMLSource::~AboutUIHTMLSource() {}
 
 std::string AboutUIHTMLSource::GetSource() {
   return source_name_;
 }
 
-void AboutUIHTMLSource::StartDataRequest(const std::string& path,
-                                         bool is_incognito,
-                                         int request_id) {
+void AboutUIHTMLSource::StartDataRequest(
+    const std::string& path,
+    bool is_incognito,
+    const content::URLDataSource::GotDataCallback& callback) {
   std::string response;
   // Add your data source here, in alphabetical order.
   if (source_name_ == chrome::kChromeUIChromeURLsHost) {
     response = ChromeURLs();
   } else if (source_name_ == chrome::kChromeUICreditsHost) {
     int idr = (path == kCreditsJsPath) ? IDR_CREDITS_JS : IDR_CREDITS_HTML;
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         idr).as_string();
 #if defined(OS_CHROMEOS)
   } else if (source_name_ == chrome::kChromeUIDiscardsHost) {
     response = AboutDiscards(path);
 #endif
 #if defined(USE_ASH)
   } else if (source_name_ == chrome::kChromeUITransparencyHost) {
     response = AboutTransparency(path);
 #endif
   } else if (source_name_ == chrome::kChromeUIDNSHost) {
-    AboutDnsHandler::Start(AsWeakPtr(), request_id);
+    AboutDnsHandler::Start(profile(), callback);
     return;
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
   } else if (source_name_ == chrome::kChromeUILinuxProxyConfigHost) {
     response = AboutLinuxProxyConfig();
 #endif
   } else if (source_name_ == chrome::kChromeUIMemoryHost) {
     response = GetAboutMemoryRedirectResponse(profile());
   } else if (source_name_ == chrome::kChromeUIMemoryRedirectHost) {
-    FinishMemoryDataRequest(path, this, request_id);
+    FinishMemoryDataRequest(path, this, callback);
     return;
 #if defined(OS_CHROMEOS)
   } else if (source_name_ == chrome::kChromeUINetworkHost) {
     response = chromeos::about_ui::AboutNetwork(path);
   } else if (source_name_ == chrome::kChromeUIOSCreditsHost) {
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_OS_CREDITS_HTML).as_string();
 #endif
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
   } else if (source_name_ == chrome::kChromeUISandboxHost) {
     response = AboutSandbox();
 #endif
   } else if (source_name_ == chrome::kChromeUIStatsHost) {
     response = AboutStats(path);
   } else if (source_name_ == chrome::kChromeUITermsHost) {
 #if defined(OS_CHROMEOS)
-    ChromeOSTermsHandler::Start(AsWeakPtr(), path, request_id);
+    ChromeOSTermsHandler::Start(path, callback);
     return;
 #else
     response = l10n_util::GetStringUTF8(IDS_TERMS_HTML);
 #endif
   }
 
-  FinishDataRequest(response, request_id);
+  FinishDataRequest(response, callback);
 }
 
-void AboutUIHTMLSource::FinishDataRequest(const std::string& html,
-                                          int request_id) {
+void AboutUIHTMLSource::FinishDataRequest(
+    const std::string& html,
+    const content::URLDataSource::GotDataCallback& callback) {
   std::string html_copy(html);
-  url_data_source()->SendResponse(
-      request_id, base::RefCountedString::TakeString(&html_copy));
+  callback.Run(base::RefCountedString::TakeString(&html_copy));
 }
 
 std::string AboutUIHTMLSource::GetMimeType(const std::string& path) const {
   if (path == kCreditsJsPath ||
       path == kStatsJsPath   ||
       path == kStringsJsPath ||
       path == kMemoryJsPath) {
     return "application/javascript";
   }
   return "text/html";
 }
 
 AboutUI::AboutUI(content::WebUI* web_ui, const std::string& name)
     : WebUIController(web_ui) {
   Profile* profile = Profile::FromWebUI(web_ui);
 
 #if defined(ENABLE_THEMES)
   // Set up the chrome://theme/ source.
   ThemeSource* theme = new ThemeSource(profile);
   ChromeURLDataManager::AddDataSource(profile, theme);
 #endif
 
-  content::URLDataSourceDelegate* source = new AboutUIHTMLSource(name, profile);
-  ChromeURLDataManager::AddDataSource(profile, source);
+  ChromeURLDataManager::AddDataSource(
+      profile, new AboutUIHTMLSource(name, profile));
 }