Convert chrome_url_data_manager (previously a global) into a Singleton. This

chrome/browser/dom_ui/chrome_url_data_manager.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 "chrome/browser/dom_ui/chrome_url_data_manager.h"
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
+#include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/ref_counted_util.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/url_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_view_net_internals_job.h"
 
 #include "grit/locale_settings.h"
 
 // The URL scheme used for internal chrome resources.
 // TODO(glen): Choose a better location for this.
 static const char kChromeURLScheme[] = "chrome";
 
-// The single global instance of ChromeURLDataManager.
-ChromeURLDataManager chrome_url_data_manager;
-
 // URLRequestChromeJob is a URLRequestJob that manages running chrome-internal
 // resource requests asynchronously.
 // It hands off URL requests to ChromeURLDataManager, which asynchronously
 // calls back once the data is available.
 class URLRequestChromeJob : public URLRequestJob {
  public:
   explicit URLRequestChromeJob(URLRequest* request);
   virtual ~URLRequestChromeJob();
 
   // URLRequestJob implementation.
@@ skipping 52 matching lines @@
                             url_scheme_component)) {
     url_util::AddStandardScheme(kChromeURLScheme);
   }
 
   FilePath inspector_dir;
   if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
     // TODO(yurys): remove "inspector" source when new developer tools support
     // all features of in-process Web Inspector and Console Debugger. For the
     // time being we need to serve the same content from chrome://inspector
     // for the Console Debugger and in-process Web Inspector.
-    chrome_url_data_manager.AddFileSource("inspector", inspector_dir);
-    chrome_url_data_manager.AddFileSource(chrome::kChromeUIDevToolsHost,
-                                          inspector_dir);
+    Singleton<ChromeURLDataManager>()->AddFileSource("inspector",
+                                                     inspector_dir);
+    Singleton<ChromeURLDataManager>()->AddFileSource(
+        chrome::kChromeUIDevToolsHost, inspector_dir);
   }
 
   URLRequest::RegisterProtocolFactory(kChromeURLScheme,
                                       &ChromeURLDataManager::Factory);
   URLRequest::RegisterProtocolFactory(chrome::kPrintScheme,
                                       &ChromeURLDataManager::Factory);
 }
 
 void UnregisterURLRequestChromeJob() {
   FilePath inspector_dir;
   if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
-    chrome_url_data_manager.RemoveFileSource("inspector");
-    chrome_url_data_manager.RemoveFileSource(chrome::kChromeUIDevToolsHost);
+    Singleton<ChromeURLDataManager>()->RemoveFileSource("inspector");
+    Singleton<ChromeURLDataManager>()->RemoveFileSource(
+        chrome::kChromeUIDevToolsHost);
   }
 }
 
 // static
 void ChromeURLDataManager::URLToRequest(const GURL& url,
                                         std::string* source_name,
                                         std::string* path) {
   DCHECK(url.SchemeIs(kChromeURLScheme) || url.SchemeIs(chrome::kPrintScheme));
 
   if (!url.is_valid()) {
@@ skipping 23 matching lines @@
 
 // static
 bool ChromeURLDataManager::URLToFilePath(const GURL& url,
                                          FilePath* file_path) {
   // Parse the URL into a request for a source and path.
   std::string source_name;
   std::string relative_path;
   URLToRequest(url, &source_name, &relative_path);
 
   FileSourceMap::const_iterator i(
-      chrome_url_data_manager.file_sources_.find(source_name));
-  if (i == chrome_url_data_manager.file_sources_.end())
+      Singleton<ChromeURLDataManager>()->file_sources_.find(source_name));
+  if (i == Singleton<ChromeURLDataManager>()->file_sources_.end())
     return false;
 
   *file_path = i->second.AppendASCII(relative_path);
 
   return true;
 }
 
 ChromeURLDataManager::ChromeURLDataManager() : next_request_id_(0) { }
 
 ChromeURLDataManager::~ChromeURLDataManager() { }
@@ skipping 89 matching lines @@
     pending_requests_.erase(i);
     job->DataAvailable(bytes);
   }
 }
 
 void ChromeURLDataManager::DataSource::SendResponse(
     RequestID request_id,
     RefCountedMemory* bytes) {
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
-      NewRunnableMethod(&chrome_url_data_manager,
+      NewRunnableMethod(Singleton<ChromeURLDataManager>().get(),
                         &ChromeURLDataManager::DataAvailable,
                         request_id, scoped_refptr<RefCountedMemory>(bytes)));
 }
 
 MessageLoop* ChromeURLDataManager::DataSource::MessageLoopForRequestPath(
     const std::string& path) const {
   return message_loop_;
 }
 
 // static
@@ skipping 54 matching lines @@
   return new URLRequestChromeJob(request);
 }
 
 URLRequestChromeJob::URLRequestChromeJob(URLRequest* request)
     : URLRequestJob(request),
       data_offset_(0),
       pending_buf_size_(0) {
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
-  CHECK(!chrome_url_data_manager.HasPendingJob(this));
+  CHECK(!Singleton<ChromeURLDataManager>()->HasPendingJob(this));
 }
 
 void URLRequestChromeJob::Start() {
   // Start reading asynchronously so that all error reporting and data
   // callbacks happen as they would for network requests.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestChromeJob::StartAsync));
 }
 
 void URLRequestChromeJob::Kill() {
-  chrome_url_data_manager.RemoveRequest(this);
+  Singleton<ChromeURLDataManager>()->RemoveRequest(this);
 }
 
 bool URLRequestChromeJob::GetMimeType(std::string* mime_type) const {
   *mime_type = mime_type_;
   return !mime_type_.empty();
 }
 
 void URLRequestChromeJob::DataAvailable(RefCountedMemory* bytes) {
   if (bytes) {
     // The request completed, and we have all the data.
@@ skipping 39 matching lines @@
     memcpy(buf->data(), data_->front() + data_offset_, buf_size);
     data_offset_ += buf_size;
   }
   *bytes_read = buf_size;
 }
 
 void URLRequestChromeJob::StartAsync() {
   if (!request_)
     return;
 
-  if (chrome_url_data_manager.StartRequest(request_->url(), this)) {
+  if (Singleton<ChromeURLDataManager>()->StartRequest(request_->url(), this)) {
     NotifyHeadersComplete();
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
                                       net::ERR_INVALID_URL));
   }
 }
 
 URLRequestChromeFileJob::URLRequestChromeFileJob(URLRequest* request,
                                                  const FilePath& path)
     : URLRequestFileJob(request, path) {
 }
 
 URLRequestChromeFileJob::~URLRequestChromeFileJob() { }