Move is_incognito bit out of ChromeURLRequestContext

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"
 #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/path_service.h"
 #include "base/string_util.h"
-#include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/ui/webui/shared_resources_data_source.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.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/http/http_response_headers.h"
@@ skipping 168 matching lines @@
 
 }  // namespace
 
 // 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);
+                      ChromeURLDataManagerBackend* 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;
 
   // Used to notify that the requested data's |mime_type| is ready.
   void MimeTypeAvailable(const std::string& mime_type);
 
   // Called by ChromeURLDataManager to notify us that the data blob is ready
   // for us.
   void DataAvailable(base::RefCountedMemory* bytes);
 
   void set_mime_type(const std::string& mime_type) {
     mime_type_ = mime_type;
   }
 
   void set_allow_caching(bool allow_caching) {
     allow_caching_ = allow_caching;
   }
 
+  // Returns true when job was generated from an incognito profile.
+  bool is_incognito() const {
+    return is_incognito_;
+  }
+
  private:
   virtual ~URLRequestChromeJob();
 
   // Helper for Start(), to let us start asynchronously.
   // (This pattern is shared by most net::URLRequestJob implementations.)
   void StartAsync();
 
   // Do the actual copy from data_ (the data we're serving) into |buf|.
   // Separate from ReadRawData so we can handle async I/O.
   void CompleteRead(net::IOBuffer* buf, int buf_size, int* bytes_read);
 
   // The actual data we're serving.  NULL until it's been fetched.
   scoped_refptr<base::RefCountedMemory> data_;
   // 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_;
 
   // If true, set a header in the response to prevent it from being cached.
   bool allow_caching_;
 
+  // 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_;
 
   base::WeakPtrFactory<URLRequestChromeJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
 };
 
 URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request,
                                          net::NetworkDelegate* network_delegate,
-                                         ChromeURLDataManagerBackend* backend)
+                                         ChromeURLDataManagerBackend* backend,
+                                         bool is_incognito)
     : net::URLRequestJob(request, network_delegate),
       data_offset_(0),
       pending_buf_size_(0),
       allow_caching_(true),
+      is_incognito_(is_incognito),
       backend_(backend),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(backend);
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
   CHECK(!backend_->HasPendingJob(this));
 }
 
 void URLRequestChromeJob::Start() {
@@ skipping 110 matching lines @@
       base::Bind(&URLRequestChromeJob::MimeTypeAvailable, job, mime_type));
 }
 
 }  // namespace
 
 namespace {
 
 class ChromeProtocolHandler
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
-  explicit ChromeProtocolHandler(ChromeURLDataManagerBackend* backend);
+  // |is_incognito| should be set for incognito profiles.
+  explicit ChromeProtocolHandler(ChromeURLDataManagerBackend* 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_;
 
+  // True when generated from an incognito profile.
+  const bool is_incognito_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromeProtocolHandler);
 };
 
 ChromeProtocolHandler::ChromeProtocolHandler(
-    ChromeURLDataManagerBackend* backend)
-    : backend_(backend) {}
+    ChromeURLDataManagerBackend* 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_);
+  return new URLRequestChromeJob(request, network_delegate, backend_,
+                                 is_incognito_);
 }
 
 }  // namespace
 
 ChromeURLDataManagerBackend::ChromeURLDataManagerBackend()
     : next_request_id_(0) {
   content::URLDataSource* shared_source = new SharedResourcesDataSource();
   URLDataSourceImpl* source_impl =
       new URLDataSourceImpl(shared_source->GetSource(), shared_source);
   AddDataSource(source_impl);
 }
 
 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) {
+    ChromeURLDataManagerBackend* backend, bool is_incognito) {
   DCHECK(backend);
-  return new ChromeProtocolHandler(backend);
+  return new ChromeProtocolHandler(backend, is_incognito);
 }
 
 void ChromeURLDataManagerBackend::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;
@@ skipping 25 matching lines @@
     return false;
 
   URLDataSourceImpl* 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->source()->AllowCaching());
 
-  const ChromeURLRequestContext* context =
-      static_cast<const ChromeURLRequestContext*>(job->request()->context());
-
   // Forward along the request to the data source.
   MessageLoop* target_message_loop =
       source->source()->MessageLoopForRequestPath(path);
   if (!target_message_loop) {
     job->MimeTypeAvailable(source->source()->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->source()->StartDataRequest(
-        path, context->is_incognito(),
+        path, job->is_incognito(),
         base::Bind(&URLDataSourceImpl::SendResponse, source, 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<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,
-                   make_scoped_refptr(source), path, context->is_incognito(),
+                   make_scoped_refptr(source), path, job->is_incognito(),
                    request_id));
   }
   return true;
 }
 
 void ChromeURLDataManagerBackend::CallStartRequest(
     scoped_refptr<URLDataSourceImpl> source,
     const std::string& path,
     bool is_incognito,
     int request_id) {
@@ skipping 68 matching lines @@
     return false;
 
   *path = inspector_dir.AppendASCII(relative_path);
   return true;
 }
 #endif  // defined(DEBUG_DEVTOOLS)
 
 class DevToolsJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
+  // |is_incognito| should be set for incognito profiles.
   DevToolsJobFactory(ChromeURLDataManagerBackend* backend,
-                     net::NetworkDelegate* network_delegate);
+                     net::NetworkDelegate* network_delegate,
+                     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_;
   net::NetworkDelegate* network_delegate_;
 
+  // True when generated from an incognito profile.
+  const bool is_incognito_;
+
   DISALLOW_COPY_AND_ASSIGN(DevToolsJobFactory);
 };
 
 DevToolsJobFactory::DevToolsJobFactory(ChromeURLDataManagerBackend* backend,
-                                       net::NetworkDelegate* network_delegate)
+                                       net::NetworkDelegate* network_delegate,
+                                       bool is_incognito)
     : backend_(backend),
-      network_delegate_(network_delegate) {
+      network_delegate_(network_delegate),
+      is_incognito_(is_incognito) {
   DCHECK(backend_);
 }
 
 DevToolsJobFactory::~DevToolsJobFactory() {}
 
 net::URLRequestJob*
 DevToolsJobFactory::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
 #if defined(DEBUG_DEVTOOLS)
   FilePath path;
   if (IsSupportedDevToolsURL(request->url(), &path))
     return new net::URLRequestFileJob(request, network_delegate, path);
 #endif
-  return new URLRequestChromeJob(request, network_delegate, backend_);
+  return new URLRequestChromeJob(request, network_delegate, backend_,
+                                 is_incognito_);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(ChromeURLDataManagerBackend* backend,
-                              net::NetworkDelegate* network_delegate) {
-  return new DevToolsJobFactory(backend, network_delegate);
+                              net::NetworkDelegate* network_delegate,
+                              bool is_incognito) {
+  return new DevToolsJobFactory(backend, network_delegate, is_incognito);
 }