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

chrome/browser/ui/webui/chrome_url_data_manager_backend.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/chrome_url_data_manager_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 372 matching lines @@
                                            net::ERR_INVALID_URL));
   }
 }
 
 namespace {
 
 // Gets mime type for data that is available from |source| by |path|.
 // After that, notifies |job| that mime type is available. This method
 // should be called on the UI thread, but notification is performed on
 // the IO thread.
-void GetMimeTypeOnUI(ChromeURLDataManager::DataSource* source,
+void GetMimeTypeOnUI(URLDataSource* source,
                      const std::string& path,
                      const base::WeakPtr<URLRequestChromeJob>& job) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::string mime_type = source->GetMimeType(path);
+  std::string mime_type = source->delegate()->GetMimeType(path);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestChromeJob::MimeTypeAvailable, job, mime_type));
 }
 
 }  // namespace
 
 namespace {
 
 class ChromeProtocolHandler
@@ skipping 24 matching lines @@
   DCHECK(request);
 
   // Fall back to using a custom handler
   return new URLRequestChromeJob(request, network_delegate, backend_);
 }
 
 }  // namespace
 
 ChromeURLDataManagerBackend::ChromeURLDataManagerBackend()
     : next_request_id_(0) {
-  AddDataSource(new SharedResourcesDataSource());
+  content::URLDataSourceDelegate* shared_source =
+      new SharedResourcesDataSource();
+  shared_source->url_data_source_ =
+      new URLDataSource(shared_source->GetSource(), shared_source);
+  AddDataSource(shared_source->url_data_source_);
 }
 
 ChromeURLDataManagerBackend::~ChromeURLDataManagerBackend() {
   for (DataSourceMap::iterator i = data_sources_.begin();
        i != data_sources_.end(); ++i) {
     i->second->backend_ = NULL;
   }
   data_sources_.clear();
 }
 
 // static
 net::URLRequestJobFactory::ProtocolHandler*
 ChromeURLDataManagerBackend::CreateProtocolHandler(
     ChromeURLDataManagerBackend* backend) {
   DCHECK(backend);
   return new ChromeProtocolHandler(backend);
 }
 
 void ChromeURLDataManagerBackend::AddDataSource(
-    ChromeURLDataManager::DataSource* source) {
+    URLDataSource* source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DataSourceMap::iterator i = data_sources_.find(source->source_name());
   if (i != data_sources_.end()) {
-    if (!source->ShouldReplaceExistingSource())
+    if (!source->delegate()->ShouldReplaceExistingSource())
       return;
     i->second->backend_ = NULL;
   }
   data_sources_[source->source_name()] = source;
   source->backend_ = this;
 }
 
 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 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;
 
-  ChromeURLDataManager::DataSource* source = i->second;
+  URLDataSource* 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));
 
-  job->set_allow_caching(source->AllowCaching());
+  job->set_allow_caching(source->delegate()->AllowCaching());
 
   const ChromeURLRequestContext* context =
       static_cast<const ChromeURLRequestContext*>(job->request()->context());
 
   // Forward along the request to the data source.
-  MessageLoop* target_message_loop = source->MessageLoopForRequestPath(path);
+  MessageLoop* target_message_loop =
+      source->delegate()->MessageLoopForRequestPath(path);
   if (!target_message_loop) {
-    job->MimeTypeAvailable(source->GetMimeType(path));
+    job->MimeTypeAvailable(source->delegate()->GetMimeType(path));
 
     // 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_incognito(), request_id);
+    source->delegate()->StartDataRequest(
+        path, context->is_incognito(), request_id);
   } else {
     // URLRequestChromeJob should receive mime type before data. This
     // is guaranteed because request for mime type is placed in the
     // message loop before request for data. And correspondingly their
     // replies are put on the IO thread in the same order.
     target_message_loop->PostTask(
         FROM_HERE,
         base::Bind(&GetMimeTypeOnUI,
-                   scoped_refptr<ChromeURLDataManager::DataSource>(source),
+                   scoped_refptr<URLDataSource>(source),
                    path, job->AsWeakPtr()));
 
     // The DataSource wants StartDataRequest to be called on a specific thread,
     // usually the UI thread, for this path.
     target_message_loop->PostTask(
         FROM_HERE,
-        base::Bind(&ChromeURLDataManager::DataSource::StartDataRequest, source,
-                   path, context->is_incognito(), request_id));
+        base::Bind(&ChromeURLDataManagerBackend::CallStartRequest,
+                   make_scoped_refptr(source), path, context->is_incognito(),
+                   request_id));
   }
   return true;
 }
 
+void ChromeURLDataManagerBackend::CallStartRequest(
+    scoped_refptr<URLDataSource> source,
+    const std::string& path,
+    bool is_incognito,
+    int request_id) {
+  source->delegate()->StartDataRequest(path, is_incognito, request_id);
+}
+
 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;
     }
@@ skipping 96 matching lines @@
   return new URLRequestChromeJob(request, network_delegate, backend_);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(ChromeURLDataManagerBackend* backend,
                               net::NetworkDelegate* network_delegate) {
   return new DevToolsJobFactory(backend, network_delegate);
 }