Add a new GetInstance() method for singleton classes used in chrome/browser files.

chrome/browser/dom_ui/chrome_url_data_manager.cc

 // Copyright (c) 2010 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/i18n/rtl.h"
 #include "base/message_loop.h"
@@ skipping 78 matching lines @@
 
  private:
   virtual ~URLRequestChromeFileJob();
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeFileJob);
 };
 
 void RegisterURLRequestChromeJob() {
   FilePath inspector_dir;
   if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
-    Singleton<ChromeURLDataManager>()->AddFileSource(
+    ChromeURLDataManager::GetInstance()->AddFileSource(
         chrome::kChromeUIDevToolsHost, inspector_dir);
   }
 
   SharedResourcesDataSource::Register();
   net::URLRequest::RegisterProtocolFactory(chrome::kChromeDevToolsScheme,
                                            &ChromeURLDataManager::Factory);
   net::URLRequest::RegisterProtocolFactory(chrome::kChromeUIScheme,
                                            &ChromeURLDataManager::Factory);
 }
 
 void UnregisterURLRequestChromeJob() {
   FilePath inspector_dir;
   if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
-    Singleton<ChromeURLDataManager>()->RemoveFileSource(
+    ChromeURLDataManager::GetInstance()->RemoveFileSource(
         chrome::kChromeUIDevToolsHost);
   }
 }
 
 // static
 void ChromeURLDataManager::URLToRequest(const GURL& url,
                                         std::string* source_name,
                                         std::string* path) {
   DCHECK(url.SchemeIs(chrome::kChromeDevToolsScheme) ||
          url.SchemeIs(chrome::kChromeUIScheme));
@@ skipping 27 matching lines @@
   // Remove Query and Ref from URL.
   GURL stripped_url;
   GURL::Replacements replacements;
   replacements.ClearQuery();
   replacements.ClearRef();
   stripped_url = url.ReplaceComponents(replacements);
 
   URLToRequest(stripped_url, &source_name, &relative_path);
 
   FileSourceMap::const_iterator i(
-      Singleton<ChromeURLDataManager>()->file_sources_.find(source_name));
-  if (i == Singleton<ChromeURLDataManager>()->file_sources_.end())
+      ChromeURLDataManager::GetInstance()->file_sources_.find(source_name));
+  if (i == ChromeURLDataManager::GetInstance()->file_sources_.end())
     return false;
 
   // Check that |relative_path| is not an absolute path (otherwise AppendASCII()
   // will DCHECK). The awkward use of StringType is because on some systems
   // FilePath expects a std::string, but on others a std::wstring.
   FilePath p(FilePath::StringType(relative_path.begin(), relative_path.end()));
   if (p.IsAbsolute())
     return false;
 
   *file_path = i->second.AppendASCII(relative_path);
 
   return true;
 }
 
 ChromeURLDataManager::ChromeURLDataManager() : next_request_id_(0) { }
 
 ChromeURLDataManager::~ChromeURLDataManager() { }
 
+// static
+ChromeURLDataManager* ChromeURLDataManager::GetInstance() {
+  return Singleton<ChromeURLDataManager>::get();
+}
+
 void ChromeURLDataManager::AddDataSource(scoped_refptr<DataSource> source) {
   // TODO(jackson): A new data source with same name should not clobber the
   // existing one.
   data_sources_[source->source_name()] = source;
 }
 
 void ChromeURLDataManager::AddFileSource(const std::string& source_name,
                                          const FilePath& file_path) {
   DCHECK(file_sources_.count(source_name) == 0);
   file_sources_[source_name] = file_path;
@@ skipping 89 matching lines @@
 }
 
 ChromeURLDataManager::DataSource::~DataSource() {
 }
 
 void ChromeURLDataManager::DataSource::SendResponse(
     RequestID request_id,
     RefCountedMemory* bytes) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(Singleton<ChromeURLDataManager>::get(),
+      NewRunnableMethod(ChromeURLDataManager::GetInstance(),
                         &ChromeURLDataManager::DataAvailable,
                         request_id, scoped_refptr<RefCountedMemory>(bytes)));
 }
 
 MessageLoop* ChromeURLDataManager::DataSource::MessageLoopForRequestPath(
     const std::string& path) const {
   return message_loop_;
 }
 
 // static
@@ skipping 39 matching lines @@
   return new URLRequestChromeJob(request);
 }
 
 URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request)
     : URLRequestJob(request),
       data_offset_(0),
       pending_buf_size_(0) {
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
-  CHECK(!Singleton<ChromeURLDataManager>()->HasPendingJob(this));
+  CHECK(!ChromeURLDataManager::GetInstance()->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() {
-  Singleton<ChromeURLDataManager>()->RemoveRequest(this);
+  ChromeURLDataManager::GetInstance()->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 (Singleton<ChromeURLDataManager>()->StartRequest(request_->url(), this)) {
+  if (ChromeURLDataManager::GetInstance()->StartRequest(request_->url(),
+                                                        this)) {
     NotifyHeadersComplete();
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
                                       net::ERR_INVALID_URL));
   }
 }
 
 URLRequestChromeFileJob::URLRequestChromeFileJob(net::URLRequest* request,
                                                  const FilePath& path)
     : URLRequestFileJob(request, path) {
 }
 
 URLRequestChromeFileJob::~URLRequestChromeFileJob() { }