Splits ChromeURLDataManager into 2 chunks:...

chrome/browser/dom_ui/chrome_url_data_manager_backend.cc

 // Copyright (c) 2011 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 "chrome/browser/dom_ui/chrome_url_data_manager_backend.h"
 
 #include "base/file_util.h"
-#include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/ref_counted_memory.h"
-#include "base/singleton.h"
-#include "base/stl_util-inl.h"
 #include "base/string_util.h"
-#include "base/threading/thread.h"
-#include "base/values.h"
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
 #include "chrome/browser/appcache/view_appcache_internals_job_factory.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/dom_ui/shared_resources_data_source.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/view_blob_internals_job_factory.h"
 #include "chrome/browser/net/view_http_cache_job_factory.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 "grit/platform_locale_settings.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 "ui/base/l10n/l10n_util.h"
+
+static ChromeURLDataManagerBackend* GetBackend(net::URLRequest* request) {
+  return static_cast<ChromeURLRequestContext*>(request->context())->
+      GetChromeURLDataManagerBackend();
+}
 
 // URLRequestChromeJob is a net::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 net::URLRequestJob {
  public:
   explicit URLRequestChromeJob(net::URLRequest* request);
 
   // net::URLRequestJob implementation.
@@ skipping 26 matching lines @@
   // The current offset into the data that we're handing off to our
   // callers via the Read interfaces.
   int data_offset_;
 
   // For async reads, we keep around a pointer to the buffer that
   // we're reading into.
   scoped_refptr<net::IOBuffer> pending_buf_;
   int pending_buf_size_;
   std::string mime_type_;
 
+  scoped_refptr<ChromeURLDataManagerBackend> backend_;
+
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
 };
 
 // URLRequestChromeFileJob is a net::URLRequestJob that acts like a file:// URL
 class URLRequestChromeFileJob : public net::URLRequestFileJob {
  public:
   URLRequestChromeFileJob(net::URLRequest* request, const FilePath& path);
 
  private:
   virtual ~URLRequestChromeFileJob();
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeFileJob);
 };
 
-void RegisterURLRequestChromeJob() {
-  FilePath inspector_dir;
-  if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
-    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)) {
-    ChromeURLDataManager::GetInstance()->RemoveFileSource(
-        chrome::kChromeUIDevToolsHost);
-  }
-}
-
-// static
-void ChromeURLDataManager::URLToRequest(const GURL& url,
-                                        std::string* source_name,
-                                        std::string* path) {
+void ChromeURLDataManagerBackend::URLToRequest(const GURL& url,
+                                               std::string* source_name,
+                                               std::string* path) {
   DCHECK(url.SchemeIs(chrome::kChromeDevToolsScheme) ||
          url.SchemeIs(chrome::kChromeUIScheme));
 
   if (!url.is_valid()) {
     NOTREACHED();
     return;
   }
 
   // Our input looks like: chrome://source_name/extra_bits?foo .
   // So the url's "host" is our source, and everything after the host is
   // the path.
   source_name->assign(url.host());
 
   const std::string& spec = url.possibly_invalid_spec();
   const url_parse::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
   // + 1 to skip the slash at the beginning of the path.
   int offset = parsed.CountCharactersBefore(url_parse::Parsed::PATH, false) + 1;
 
   if (offset < static_cast<int>(spec.size()))
     path->assign(spec.substr(offset));
 }
 
-// static
-bool ChromeURLDataManager::URLToFilePath(const GURL& url,
-                                         FilePath* file_path) {
+bool ChromeURLDataManagerBackend::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;
 
   // 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(
-      ChromeURLDataManager::GetInstance()->file_sources_.find(source_name));
-  if (i == ChromeURLDataManager::GetInstance()->file_sources_.end())
+  FileSourceMap::const_iterator i(file_sources_.find(source_name));
+  if (i == 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) { }
+// static
+base::Lock* ChromeURLDataManagerBackend::instances_lock_ = NULL;
 
-ChromeURLDataManager::~ChromeURLDataManager() {
-  // This is used as a Singleton, so it is only called at exit cleanup time.
-  // This means it is called on the main (UI) thread.
-  //
-  // It will break if it is called at shutdown time on a different thread, as
-  // it will attempt to call the destructors for its |data_source_|s on the
-  // UI thread, but the UI thread's message loop will be not be running
-  // -- so the destructor calls will be dropped and we will leak the objects.
+// static
+ChromeURLDataManagerBackend::Instances*
+    ChromeURLDataManagerBackend::instances_ = NULL;
+
+// static
+ChromeURLDataManagerBackend::LockedInstances*
+    ChromeURLDataManagerBackend::shutdown_instances_ = NULL;
+
+ChromeURLDataManagerBackend::ChromeURLDataManagerBackend()
+    : next_request_id_(0) {
+  FilePath inspector_dir;
+  if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir))
+    AddFileSource(chrome::kChromeUIDevToolsHost, inspector_dir);
+  AddDataSource(new SharedResourcesDataSource());
+  {
+    base::AutoLock lock(*instances_lock_);

[Evan Martin, 2011/02/07 19:06:21]

It seems you have a precondition that ::Register() is called (to create the
lock) before this ctor is called (?).  Is that because Register is static? 
Maybe it needs the "// static" line above it at L174

+    instances_->push_back(this);
+    if (shutdown_instances_)
+      shutdown_instances_->push_back(this);
+  }
+}
+
+void ChromeURLDataManagerBackend::Register() {
+  net::URLRequest::RegisterProtocolFactory(
+      chrome::kChromeDevToolsScheme,
+      &ChromeURLDataManagerBackend::Factory);
+  net::URLRequest::RegisterProtocolFactory(
+      chrome::kChromeUIScheme,
+      &ChromeURLDataManagerBackend::Factory);
+  DCHECK(!instances_lock_);
+  instances_lock_ = new base::Lock();
+  DCHECK(!instances_);
+  instances_ = new Instances();
 }
 
 // static
-ChromeURLDataManager* ChromeURLDataManager::GetInstance() {
-  return Singleton<ChromeURLDataManager>::get();
+void ChromeURLDataManagerBackend::PrepareForShutdown() {
+  base::AutoLock lock(*instances_lock_);
+  DCHECK(!shutdown_instances_);
+  // Create LockedInstances and all existing instances to it so that none of the
+  // existing instances get destroyed. We need to do this otherwise by the time
+  // CompleteShutdown is invoked all the ChromeURLDataManagerBackends will
+  // likely have been destroyed along with their DataSources. But because the UI
+  // thread is no longer running, all the DataSources end up leaking. By
+  // delaying the destruction until CompleteShutdown is invoked on the UI
+  // thread, we know everything gets destroyed on the UI thread.
+  shutdown_instances_ = new LockedInstances();
+  for (Instances::iterator i = instances_->begin(); i != instances_->end(); ++i)
+    shutdown_instances_->push_back(make_scoped_refptr(*i));
 }
 
-void ChromeURLDataManager::AddDataSource(scoped_refptr<DataSource> source) {
-  // Some |DataSource|-derived classes, notably |FileIconSource| and
-  // |WebUIFavIconSource|, have members that will DCHECK if they are not
-  // destructed in the same thread as they are constructed (the UI thread).
-  //
-  // If |AddDataSource| is called more than once, it will destruct the object
-  // that it had before, as it is the only thing still holding a reference to
-  // that object.  |DataSource| uses the |DeleteOnUIThread| trait to insure
-  // that the destructor is called on the UI thread.
-  //
-  // TODO(jackson): A new data source with same name should not clobber the
-  // existing one.
-  data_sources_[source->source_name()] = source;
-}
-
-void ChromeURLDataManager::RemoveDataSourceForTest(const char* source_name) {
-  DataSourceMap::iterator i = data_sources_.find(source_name);
-  if (i == data_sources_.end())
-    return;
-  (*i).second = NULL;  // Calls Release().
-  data_sources_.erase(i);
-}
-
-void ChromeURLDataManager::RemoveAllDataSources() {
-  for (DataSourceMap::iterator i = data_sources_.begin();
-       i != data_sources_.end();
-       i = data_sources_.begin()) {
-    (*i).second = NULL;  // Calls Release().
-    data_sources_.erase(i);
+// static
+void ChromeURLDataManagerBackend::CompleteShutdown() {
+  LockedInstances instances;
+  {
+    base::AutoLock lock(*instances_lock_);
+    DCHECK(shutdown_instances_);  // PrepareForShutdown must have been invoked.
+    instances.swap(*shutdown_instances_);
+    delete shutdown_instances_;
+    shutdown_instances_ = NULL;
+  }
+  for (LockedInstances::iterator i = instances.begin(); i != instances.end();
+       ++i) {
+    (*i)->ReleaseDataSources();
   }
 }
 
-void ChromeURLDataManager::AddFileSource(const std::string& source_name,
-                                         const FilePath& file_path) {
+ChromeURLDataManagerBackend::~ChromeURLDataManagerBackend() {
+  {
+    base::AutoLock lock(*instances_lock_);
+    instances_->erase(std::find(instances_->begin(), instances_->end(), this));
+  }
+  ReleaseDataSources();
+}
+
+void ChromeURLDataManagerBackend::AddDataSource(
+    ChromeURLDataManager::DataSource* source) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  base::AutoLock lock(data_sources_lock_);
+  DataSourceMap::iterator i = data_sources_.find(source->source_name());
+  if (i != data_sources_.end())
+    i->second->backend_ = NULL;
+  data_sources_[source->source_name()] = source;
+  source->backend_ = this;
+}
+
+void ChromeURLDataManagerBackend::AddFileSource(const std::string& source_name,
+                                                const FilePath& file_path) {
   DCHECK(file_sources_.count(source_name) == 0);
   file_sources_[source_name] = file_path;
 }
 
-void ChromeURLDataManager::RemoveFileSource(const std::string& source_name) {
-  DCHECK(file_sources_.count(source_name) == 1);
-  file_sources_.erase(source_name);
-}
-
-bool ChromeURLDataManager::HasPendingJob(URLRequestChromeJob* job) const {
+bool ChromeURLDataManagerBackend::HasPendingJob(
+    URLRequestChromeJob* job) const {
   for (PendingRequestMap::const_iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
     if (i->second == job)
       return true;
   }
-
   return false;
 }
 
-bool ChromeURLDataManager::StartRequest(const GURL& url,
-                                        URLRequestChromeJob* job) {
+bool ChromeURLDataManagerBackend::StartRequest(const GURL& url,
+                                               URLRequestChromeJob* job) {
   // Parse the URL into a request for a source and path.
   std::string source_name;
   std::string path;
   URLToRequest(url, &source_name, &path);
 
   // Look up the data source for the request.
-  DataSourceMap::iterator i = data_sources_.find(source_name);
-  if (i == data_sources_.end())
-    return false;
-  DataSource* source = i->second;
+  scoped_refptr<ChromeURLDataManager::DataSource> source;
+  {
+    base::AutoLock lock(data_sources_lock_);
+    DataSourceMap::iterator i = data_sources_.find(source_name);
+    if (i == data_sources_.end())
+      return false;
+    source = i->second;
+  }
 
   // Save this request so we know where to send the data.
   RequestID request_id = next_request_id_++;
   pending_requests_.insert(std::make_pair(request_id, job));
 
   // TODO(eroman): would be nicer if the mimetype were set at the same time
   // as the data blob. For now do it here, since NotifyHeadersComplete() is
   // going to get called once we return.
   job->SetMimeType(source->GetMimeType(path));
 
   ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>(
       job->request()->context());
 
   // Forward along the request to the data source.
   MessageLoop* target_message_loop = source->MessageLoopForRequestPath(path);
   if (!target_message_loop) {
     // The DataSource is agnostic to which thread StartDataRequest is called
     // on for this path.  Call directly into it from this thread, the IO
     // thread.
     source->StartDataRequest(path, context->is_off_the_record(), request_id);
   } else {
     // The DataSource wants StartDataRequest to be called on a specific thread,
     // usually the UI thread, for this path.
-    target_message_loop->PostTask(FROM_HERE,
-        NewRunnableMethod(source, &DataSource::StartDataRequest,
+    target_message_loop->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(source.get(),
+                          &ChromeURLDataManager::DataSource::StartDataRequest,
                           path, context->is_off_the_record(), request_id));
   }
   return true;
 }
 
-void ChromeURLDataManager::RemoveRequest(URLRequestChromeJob* job) {
+void ChromeURLDataManagerBackend::RemoveRequest(URLRequestChromeJob* job) {
   // Remove the request from our list of pending requests.
   // If/when the source sends the data that was requested, the data will just
   // be thrown away.
   for (PendingRequestMap::iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
     if (i->second == job) {
       pending_requests_.erase(i);
       return;
     }
   }
 }
 
-void ChromeURLDataManager::DataAvailable(
-    RequestID request_id,
-    scoped_refptr<RefCountedMemory> bytes) {
+void ChromeURLDataManagerBackend::DataAvailable(RequestID request_id,
+                                                RefCountedMemory* bytes) {
   // Forward this data on to the pending net::URLRequest, if it exists.
   PendingRequestMap::iterator i = pending_requests_.find(request_id);
   if (i != pending_requests_.end()) {
     // We acquire a reference to the job so that it doesn't disappear under the
     // feet of any method invoked here (we could trigger a callback).
     scoped_refptr<URLRequestChromeJob> job(i->second);
     pending_requests_.erase(i);
     job->DataAvailable(bytes);
   }
 }
 
-ChromeURLDataManager::DataSource::DataSource(const std::string& source_name,
-                                             MessageLoop* message_loop)
-    : source_name_(source_name), message_loop_(message_loop) {
-}
-
-ChromeURLDataManager::DataSource::~DataSource() {
-}
-
-void ChromeURLDataManager::DataSource::SendResponse(
-    RequestID request_id,
-    RefCountedMemory* bytes) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(ChromeURLDataManager::GetInstance(),
-                        &ChromeURLDataManager::DataAvailable,
-                        request_id, scoped_refptr<RefCountedMemory>(bytes)));
-}
-
-MessageLoop* ChromeURLDataManager::DataSource::MessageLoopForRequestPath(
-    const std::string& path) const {
-  return message_loop_;
+void ChromeURLDataManagerBackend::ReleaseDataSources() {
+  DataSourceMap data_sources;
+  {
+    base::AutoLock lock(data_sources_lock_);
+    data_sources.swap(data_sources_);
+  }
+  for (DataSourceMap::iterator i = data_sources.begin();
+       i != data_sources.end(); ++i) {
+    i->second->backend_ = NULL;
+  }
 }
 
 // static
-void ChromeURLDataManager::DataSource::SetFontAndTextDirection(
-    DictionaryValue* localized_strings) {
-  localized_strings->SetString("fontfamily",
-      l10n_util::GetStringUTF16(IDS_WEB_FONT_FAMILY));
-
-  int web_font_size_id = IDS_WEB_FONT_SIZE;
-#if defined(OS_WIN)
-  // Some fonts used for some languages changed a lot in terms of the font
-  // metric in Vista. So, we need to use different size before Vista.
-  if (base::win::GetVersion() < base::win::VERSION_VISTA)
-    web_font_size_id = IDS_WEB_FONT_SIZE_XP;
-#endif
-  localized_strings->SetString("fontsize",
-      l10n_util::GetStringUTF16(web_font_size_id));
-
-  localized_strings->SetString("textdirection",
-      base::i18n::IsRTL() ? "rtl" : "ltr");
-}
-
-net::URLRequestJob* ChromeURLDataManager::Factory(net::URLRequest* request,
-                                                  const std::string& scheme) {
+net::URLRequestJob* ChromeURLDataManagerBackend::Factory(
+    net::URLRequest* request,
+    const std::string& scheme) {
   // Try first with a file handler
   FilePath path;
-  if (ChromeURLDataManager::URLToFilePath(request->url(), &path))
+  ChromeURLDataManagerBackend* backend = GetBackend(request);
+  if (backend->URLToFilePath(request->url(), &path))
     return new URLRequestChromeFileJob(request, path);
 
   // Next check for chrome://view-http-cache/*, which uses its own job type.
   if (ViewHttpCacheJobFactory::IsSupportedURL(request->url()))
     return ViewHttpCacheJobFactory::CreateJobForRequest(request);
 
   // Next check for chrome://appcache-internals/, which uses its own job type.
   if (ViewAppCacheInternalsJobFactory::IsSupportedURL(request->url()))
     return ViewAppCacheInternalsJobFactory::CreateJobForRequest(request);
 
   // Next check for chrome://blob-internals/, which uses its own job type.
   if (ViewBlobInternalsJobFactory::IsSupportedURL(request->url()))
     return ViewBlobInternalsJobFactory::CreateJobForRequest(request);
 
   // Fall back to using a custom handler
   return new URLRequestChromeJob(request);
 }
 
 URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request)
     : net::URLRequestJob(request),
       data_offset_(0),
-      pending_buf_size_(0) {
+      pending_buf_size_(0),
+      backend_(GetBackend(request)) {
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
-  CHECK(!ChromeURLDataManager::GetInstance()->HasPendingJob(this));
+  CHECK(!backend_->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() {
-  ChromeURLDataManager::GetInstance()->RemoveRequest(this);
+  backend_->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 40 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 (ChromeURLDataManager::GetInstance()->StartRequest(request_->url(),
-                                                        this)) {
+  if (backend_->StartRequest(request_->url(), this)) {
     NotifyHeadersComplete();
   } else {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_INVALID_URL));
   }
 }
 
 URLRequestChromeFileJob::URLRequestChromeFileJob(net::URLRequest* request,
                                                  const FilePath& path)
     : net::URLRequestFileJob(request, path) {
 }
 
-URLRequestChromeFileJob::~URLRequestChromeFileJob() { }
+URLRequestChromeFileJob::~URLRequestChromeFileJob() {}