Clean up of url data manager classes in content: move URLDataSourceImpl to its own file, move all t…

content/browser/webui/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 "content/browser/webui/url_data_manager_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "content/browser/webui/shared_resources_data_source.h"
+#include "content/browser/webui/url_data_source_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/url_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 
-using content::BrowserThread;
+namespace content {
 
 namespace {
 
 // TODO(tsepez) remove unsafe-eval when bidichecker_packaged.js fixed.
 const char kChromeURLContentSecurityPolicyHeaderBase[] =
     "Content-Security-Policy: script-src chrome://resources "
     "'self' 'unsafe-eval'; ";
 
 const char kChromeURLXFrameOptionsHeader[] = "X-Frame-Options: DENY";
 
@@ skipping 28 matching lines @@
 // 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 base::SupportsWeakPtr<URLRequestChromeJob> {
  public:
   // |is_incognito| set when job is generated from an incognito profile.
   URLRequestChromeJob(net::URLRequest* request,
                       net::NetworkDelegate* network_delegate,
-                      ChromeURLDataManagerBackend* backend,
+                      URLDataManagerBackend* backend,
                       bool is_incognito);
 
   // net::URLRequestJob implementation.
   virtual void Start() OVERRIDE;
   virtual void Kill() OVERRIDE;
   virtual bool ReadRawData(net::IOBuffer* buf,
                            int buf_size,
                            int* bytes_read) OVERRIDE;
   virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE;
@@ skipping 69 matching lines @@
   std::string content_security_policy_object_source_;
   std::string content_security_policy_frame_source_;
 
   // If true, sets  the "X-Frame-Options: DENY" header.
   bool deny_xframe_options_;
 
   // True when job is generated from an incognito profile.
   const bool is_incognito_;
 
   // The backend is owned by ChromeURLRequestContext and always outlives us.
-  ChromeURLDataManagerBackend* backend_;
+  URLDataManagerBackend* backend_;
 
   base::WeakPtrFactory<URLRequestChromeJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
 };
 
 URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request,
                                          net::NetworkDelegate* network_delegate,
-                                         ChromeURLDataManagerBackend* backend,
+                                         URLDataManagerBackend* backend,
                                          bool is_incognito)
     : net::URLRequestJob(request, network_delegate),
       data_offset_(0),
       pending_buf_size_(0),
       allow_caching_(true),
       add_content_security_policy_(true),
       content_security_policy_object_source_("object-src 'none';"),
       content_security_policy_frame_source_("frame-src 'none';"),
       deny_xframe_options_(true),
       is_incognito_(is_incognito),
@@ skipping 133 matching lines @@
 }
 
 }  // namespace
 
 namespace {
 
 class ChromeProtocolHandler
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   // |is_incognito| should be set for incognito profiles.
-  explicit ChromeProtocolHandler(ChromeURLDataManagerBackend* backend,
+  explicit ChromeProtocolHandler(URLDataManagerBackend* backend,
                                  bool is_incognito);
   ~ChromeProtocolHandler();
 
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE;
 
  private:
   // These members are owned by ProfileIOData, which owns this ProtocolHandler.
-  ChromeURLDataManagerBackend* const backend_;
+  URLDataManagerBackend* const backend_;
 
   // True when generated from an incognito profile.
   const bool is_incognito_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeProtocolHandler);
 };
 
 ChromeProtocolHandler::ChromeProtocolHandler(
-    ChromeURLDataManagerBackend* backend, bool is_incognito)
+    URLDataManagerBackend* backend, bool is_incognito)
     : backend_(backend), is_incognito_(is_incognito) {}
 
 ChromeProtocolHandler::~ChromeProtocolHandler() {}
 
 net::URLRequestJob* ChromeProtocolHandler::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   DCHECK(request);
 
   // Fall back to using a custom handler
   return new URLRequestChromeJob(request, network_delegate, backend_,
                                  is_incognito_);
 }
 
 }  // namespace
 
-ChromeURLDataManagerBackend::ChromeURLDataManagerBackend()
+URLDataManagerBackend::URLDataManagerBackend()
     : next_request_id_(0) {
-  content::URLDataSource* shared_source = new SharedResourcesDataSource();
+  URLDataSource* shared_source = new SharedResourcesDataSource();
   URLDataSourceImpl* source_impl =
       new URLDataSourceImpl(shared_source->GetSource(), shared_source);
   AddDataSource(source_impl);
 }
 
-ChromeURLDataManagerBackend::~ChromeURLDataManagerBackend() {
+URLDataManagerBackend::~URLDataManagerBackend() {
   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, bool is_incognito) {
+URLDataManagerBackend::CreateProtocolHandler(
+    URLDataManagerBackend* backend, bool is_incognito) {
   DCHECK(backend);
   return new ChromeProtocolHandler(backend, is_incognito);
 }
 
-void ChromeURLDataManagerBackend::AddDataSource(
+void URLDataManagerBackend::AddDataSource(
     URLDataSourceImpl* source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DataSourceMap::iterator i = data_sources_.find(source->source_name());
   if (i != data_sources_.end()) {
     if (!source->source()->ShouldReplaceExistingSource())
       return;
     i->second->backend_ = NULL;
   }
   data_sources_[source->source_name()] = source;
   source->backend_ = this;
 }
 
-bool ChromeURLDataManagerBackend::HasPendingJob(
+bool URLDataManagerBackend::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) {
+bool URLDataManagerBackend::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;
 
@@ skipping 36 matching lines @@
     target_message_loop->PostTask(
         FROM_HERE,
         base::Bind(&GetMimeTypeOnUI,
                    scoped_refptr<URLDataSourceImpl>(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(&ChromeURLDataManagerBackend::CallStartRequest,
+        base::Bind(&URLDataManagerBackend::CallStartRequest,
                    make_scoped_refptr(source), path, job->is_incognito(),
                    request_id));
   }
   return true;
 }
 
-void ChromeURLDataManagerBackend::CallStartRequest(
+void URLDataManagerBackend::CallStartRequest(
     scoped_refptr<URLDataSourceImpl> source,
     const std::string& path,
     bool is_incognito,
     int request_id) {
   source->source()->StartDataRequest(
       path,
       is_incognito,
       base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
 }
 
-void ChromeURLDataManagerBackend::RemoveRequest(URLRequestChromeJob* job) {
+void URLDataManagerBackend::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 ChromeURLDataManagerBackend::DataAvailable(RequestID request_id,
-                                                base::RefCountedMemory* bytes) {
+void URLDataManagerBackend::DataAvailable(RequestID request_id,
+                                          base::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()) {
     URLRequestChromeJob* job(i->second);
     pending_requests_.erase(i);
     job->DataAvailable(bytes);
   }
 }
 
 namespace {
 
 class DevToolsJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   // |is_incognito| should be set for incognito profiles.
-  DevToolsJobFactory(ChromeURLDataManagerBackend* backend,
+  DevToolsJobFactory(URLDataManagerBackend* backend,
                      bool is_incognito);
   virtual ~DevToolsJobFactory();
 
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE;
 
  private:
   // |backend_| and |network_delegate_| are owned by ProfileIOData, which owns
   // this ProtocolHandler.
-  ChromeURLDataManagerBackend* const backend_;
+  URLDataManagerBackend* const backend_;
 
   // True when generated from an incognito profile.
   const bool is_incognito_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsJobFactory);
 };
 
-DevToolsJobFactory::DevToolsJobFactory(ChromeURLDataManagerBackend* backend,
+DevToolsJobFactory::DevToolsJobFactory(URLDataManagerBackend* backend,
                                        bool is_incognito)
     : backend_(backend),
       is_incognito_(is_incognito) {
   DCHECK(backend_);
 }
 
 DevToolsJobFactory::~DevToolsJobFactory() {}
 
 net::URLRequestJob*
 DevToolsJobFactory::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   return new URLRequestChromeJob(request, network_delegate, backend_,
                                  is_incognito_);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
-CreateDevToolsProtocolHandler(ChromeURLDataManagerBackend* backend,
+CreateDevToolsProtocolHandler(URLDataManagerBackend* backend,
                               bool is_incognito) {
   return new DevToolsJobFactory(backend, is_incognito);
 }
+
+}  // namespace content