Don't derive from ChromeURLDataManager::DataSource, and instead have these classes implement a dele…

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 20 matching lines @@
 #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/chrome_web_ui_data_source.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(AboutUIHTMLSource* source, int request_id)
+  AboutMemoryHandler(const base::WeakPtr<AboutUIHTMLSource>& source,
+                     int request_id)
       : source_(source),
         request_id_(request_id) {
   }
 
   virtual void OnDetailsAvailable() OVERRIDE;
 
  private:
   ~AboutMemoryHandler() {}
 
   void BindProcessMetrics(DictionaryValue* data,
                           ProcessMemoryInformation* info);
   void AppendProcess(ListValue* child_data, ProcessMemoryInformation* info);
 
-  scoped_refptr<AboutUIHTMLSource> source_;
+  base::WeakPtr<AboutUIHTMLSource> source_;
   int request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutMemoryHandler);
 };
 
 #if defined(OS_CHROMEOS)
 class ChromeOSTermsHandler
     : public base::RefCountedThreadSafe<ChromeOSTermsHandler> {
  public:
-  static void Start(AboutUIHTMLSource* source,
+  static void Start(const base::WeakPtr<AboutUIHTMLSource>& source,
                     const std::string& path,
                     int request_id) {
     scoped_refptr<ChromeOSTermsHandler> handler(
         new ChromeOSTermsHandler(source, path, request_id));
     handler->StartOnUIThread();
   }
 
  private:
   friend class base::RefCountedThreadSafe<ChromeOSTermsHandler>;
 
-  ChromeOSTermsHandler(AboutUIHTMLSource* source,
+  ChromeOSTermsHandler(const base::WeakPtr<AboutUIHTMLSource>& source,
                        const std::string& path,
                        int request_id)
     : source_(source),
       path_(path),
       request_id_(request_id),
       // Previously we were using "initial locale" http://crbug.com/145142
       locale_(g_browser_process->GetApplicationLocale()) {
   }
 
   ~ChromeOSTermsHandler() {}
@@ skipping 32 matching lines @@
         }
       }
     }
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&ChromeOSTermsHandler::ResponseOnUIThread, this));
   }
 
   void ResponseOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (!source_)

[James Hawkins, 2013/01/14 20:30:25]

Under what circumstances would this be NULL (at a high level)?

[jam, 2013/01/14 20:33:57]

Previously, DataSource derived classes got refcounting from the parent class.
Now that these classes derive from a non-refcounted base class
(URLSourceDelegate), hopping to another thread (FILE in this case) means that
the source can be gone if the user navigated away. So basically the weak pointer
factory accomplishes roughly the same thing (not crashing) as refcounting did
before.

+      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_);
   }
 
   // Where the results are fed to.
-  scoped_refptr<AboutUIHTMLSource> source_;
+  base::WeakPtr<AboutUIHTMLSource> source_;
 
   // Path in the URL.
   std::string path_;
 
   // ID identifying the request.
   int request_id_;
 
   // Locale of the EULA.
   std::string locale_;
 
@@ skipping 267 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(AboutUIHTMLSource* source, int request_id) {
+  static void Start(const base::WeakPtr<AboutUIHTMLSource>& source,
+                    int request_id) {
     scoped_refptr<AboutDnsHandler> handler(
         new AboutDnsHandler(source, request_id));
     handler->StartOnUIThread();
   }
 
  private:
   friend class base::RefCountedThreadSafe<AboutDnsHandler>;
 
-  AboutDnsHandler(AboutUIHTMLSource* source, int request_id)
+  AboutDnsHandler(const base::WeakPtr<AboutUIHTMLSource>& source,
+                  int request_id)
       : source_(source),
         request_id_(request_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   virtual ~AboutDnsHandler() {}
 
   // Calls FinishOnUIThread() on completion.
   void StartOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 13 matching lines @@
     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));
-    source_->FinishDataRequest(data, request_id_);
+    if (source_)
+      source_->FinishDataRequest(data, request_id_);
   }
 
   // Where the results are fed to.
-  scoped_refptr<AboutUIHTMLSource> source_;
+  base::WeakPtr<AboutUIHTMLSource> source_;
 
   // ID identifying the request.
   int request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutDnsHandler);
 };
 
 void FinishMemoryDataRequest(const std::string& path,
                              AboutUIHTMLSource* source,
                              int request_id) {
   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, request_id));
+        handler(new AboutMemoryHandler(source->AsWeakPtr(), request_id));
     // 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);
   }
 }
 
@@ skipping 281 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));
-  ChromeWebUIDataSource::SetFontAndTextDirection(&load_time_data);
+  URLDataSource::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_);
 }
 
 }  // namespace
 
 // AboutUIHTMLSource ----------------------------------------------------------
 
 AboutUIHTMLSource::AboutUIHTMLSource(const std::string& source_name,
                                      Profile* profile)
-    : DataSource(source_name, MessageLoop::current()),
+    : 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) {
   std::string response;
-  std::string host = source_name();
   // Add your data source here, in alphabetical order.
-  if (host == chrome::kChromeUIChromeURLsHost) {
+  if (source_name_ == chrome::kChromeUIChromeURLsHost) {
     response = ChromeURLs();
-  } else if (host == chrome::kChromeUICreditsHost) {
+  } 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 (host == chrome::kChromeUIDiscardsHost) {
+  } else if (source_name_ == chrome::kChromeUIDiscardsHost) {
     response = AboutDiscards(path);
 #endif
 #if defined(USE_ASH)
-  } else if (host == chrome::kChromeUITransparencyHost) {
+  } else if (source_name_ == chrome::kChromeUITransparencyHost) {
     response = AboutTransparency(path);
 #endif
-  } else if (host == chrome::kChromeUIDNSHost) {
-    AboutDnsHandler::Start(this, request_id);
+  } else if (source_name_ == chrome::kChromeUIDNSHost) {
+    AboutDnsHandler::Start(AsWeakPtr(), request_id);
     return;
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
-  } else if (host == chrome::kChromeUILinuxProxyConfigHost) {
+  } else if (source_name_ == chrome::kChromeUILinuxProxyConfigHost) {
     response = AboutLinuxProxyConfig();
 #endif
-  } else if (host == chrome::kChromeUIMemoryHost) {
+  } else if (source_name_ == chrome::kChromeUIMemoryHost) {
     response = GetAboutMemoryRedirectResponse(profile());
-  } else if (host == chrome::kChromeUIMemoryRedirectHost) {
+  } else if (source_name_ == chrome::kChromeUIMemoryRedirectHost) {
     FinishMemoryDataRequest(path, this, request_id);
     return;
 #if defined(OS_CHROMEOS)
-  } else if (host == chrome::kChromeUINetworkHost) {
+  } else if (source_name_ == chrome::kChromeUINetworkHost) {
     response = chromeos::about_ui::AboutNetwork(path);
-  } else if (host == chrome::kChromeUIOSCreditsHost) {
+  } 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 (host == chrome::kChromeUISandboxHost) {
+  } else if (source_name_ == chrome::kChromeUISandboxHost) {
     response = AboutSandbox();
 #endif
-  } else if (host == chrome::kChromeUIStatsHost) {
+  } else if (source_name_ == chrome::kChromeUIStatsHost) {
     response = AboutStats(path);
-  } else if (host == chrome::kChromeUITermsHost) {
+  } else if (source_name_ == chrome::kChromeUITermsHost) {
 #if defined(OS_CHROMEOS)
-    ChromeOSTermsHandler::Start(this, path, request_id);
+    ChromeOSTermsHandler::Start(AsWeakPtr(), path, request_id);
     return;
 #else
     response = l10n_util::GetStringUTF8(IDS_TERMS_HTML);
 #endif
   }
 
   FinishDataRequest(response, request_id);
 }
 
 void AboutUIHTMLSource::FinishDataRequest(const std::string& html,
                                           int request_id) {
   std::string html_copy(html);
-  SendResponse(request_id, base::RefCountedString::TakeString(&html_copy));
+  url_data_source()->SendResponse(
+      request_id, 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
 
-  ChromeURLDataManager::DataSource* source =
-      new AboutUIHTMLSource(name, profile);
-  if (source) {
-    ChromeURLDataManager::AddDataSource(profile, source);
-  }
+  content::URLDataSourceDelegate* source = new AboutUIHTMLSource(name, profile);
+  ChromeURLDataManager::AddDataSource(profile, source);
 }