1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/webui/url_data_manager_backend.h"
6
7#include <set>
8
9#include "base/basictypes.h"
10#include "base/bind.h"
11#include "base/command_line.h"
12#include "base/compiler_specific.h"
13#include "base/debug/alias.h"
14#include "base/debug/trace_event.h"
15#include "base/lazy_instance.h"
16#include "base/memory/ref_counted.h"
17#include "base/memory/ref_counted_memory.h"
18#include "base/memory/weak_ptr.h"
19#include "base/message_loop/message_loop.h"
20#include "base/strings/string_util.h"
21#include "base/strings/stringprintf.h"
22#include "content/browser/appcache/view_appcache_internals_job.h"
23#include "content/browser/fileapi/chrome_blob_storage_context.h"
24#include "content/browser/histogram_internals_request_job.h"
25#include "content/browser/net/view_blob_internals_job_factory.h"
26#include "content/browser/net/view_http_cache_job_factory.h"
27#include "content/browser/resource_context_impl.h"
28#include "content/browser/tcmalloc_internals_request_job.h"
29#include "content/browser/webui/shared_resources_data_source.h"
30#include "content/browser/webui/url_data_source_impl.h"
31#include "content/public/browser/browser_context.h"
32#include "content/public/browser/browser_thread.h"
33#include "content/public/browser/content_browser_client.h"
34#include "content/public/browser/render_process_host.h"
35#include "content/public/browser/resource_request_info.h"
36#include "content/public/common/url_constants.h"
37#include "net/base/io_buffer.h"
38#include "net/base/net_errors.h"
39#include "net/http/http_response_headers.h"
40#include "net/http/http_status_code.h"
41#include "net/url_request/url_request.h"
42#include "net/url_request/url_request_context.h"
43#include "net/url_request/url_request_job.h"
44#include "net/url_request/url_request_job_factory.h"
45#include "url/url_util.h"
46
47namespace content {
48
49namespace {
50
51// TODO(tsepez) remove unsafe-eval when bidichecker_packaged.js fixed.
52const char kChromeURLContentSecurityPolicyHeaderBase[] =
53    "Content-Security-Policy: script-src chrome://resources "
54    "'self' 'unsafe-eval'; ";
55
56const char kChromeURLXFrameOptionsHeader[] = "X-Frame-Options: DENY";
57
58const int kNoRenderProcessId = -1;
59
60bool SchemeIsInSchemes(const std::string& scheme,
61                       const std::vector<std::string>& schemes) {
62  return std::find(schemes.begin(), schemes.end(), scheme) != schemes.end();
63}
64
65// Returns whether |url| passes some sanity checks and is a valid GURL.
66bool CheckURLIsValid(const GURL& url) {
67  std::vector<std::string> additional_schemes;
68  DCHECK(url.SchemeIs(kChromeDevToolsScheme) || url.SchemeIs(kChromeUIScheme) ||
69         (GetContentClient()->browser()->GetAdditionalWebUISchemes(
70              &additional_schemes),
71          SchemeIsInSchemes(url.scheme(), additional_schemes)));
72
73  if (!url.is_valid()) {
74    NOTREACHED();
75    return false;
76  }
77
78  return true;
79}
80
81// Parse |url| to get the path which will be used to resolve the request. The
82// path is the remaining portion after the scheme and hostname.
83void URLToRequestPath(const GURL& url, std::string* path) {
84  const std::string& spec = url.possibly_invalid_spec();
85  const url::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
86  // + 1 to skip the slash at the beginning of the path.
87  int offset = parsed.CountCharactersBefore(url::Parsed::PATH, false) + 1;
88
89  if (offset < static_cast<int>(spec.size()))
90    path->assign(spec.substr(offset));
91}
92
93}  // namespace
94
95// URLRequestChromeJob is a net::URLRequestJob that manages running
96// chrome-internal resource requests asynchronously.
97// It hands off URL requests to ChromeURLDataManager, which asynchronously
98// calls back once the data is available.
99class URLRequestChromeJob : public net::URLRequestJob,
100                            public base::SupportsWeakPtr<URLRequestChromeJob> {
101 public:
102  // |is_incognito| set when job is generated from an incognito profile.
103  URLRequestChromeJob(net::URLRequest* request,
104                      net::NetworkDelegate* network_delegate,
105                      URLDataManagerBackend* backend,
106                      bool is_incognito);
107
108  // net::URLRequestJob implementation.
109  virtual void Start() OVERRIDE;
110  virtual void Kill() OVERRIDE;
111  virtual bool ReadRawData(net::IOBuffer* buf,
112                           int buf_size,
113                           int* bytes_read) OVERRIDE;
114  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
115  virtual int GetResponseCode() const OVERRIDE;
116  virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE;
117
118  // Used to notify that the requested data's |mime_type| is ready.
119  void MimeTypeAvailable(const std::string& mime_type);
120
121  // Called by ChromeURLDataManager to notify us that the data blob is ready
122  // for us.
123  void DataAvailable(base::RefCountedMemory* bytes);
124
125  void set_mime_type(const std::string& mime_type) {
126    mime_type_ = mime_type;
127  }
128
129  void set_allow_caching(bool allow_caching) {
130    allow_caching_ = allow_caching;
131  }
132
133  void set_add_content_security_policy(bool add_content_security_policy) {
134    add_content_security_policy_ = add_content_security_policy;
135  }
136
137  void set_content_security_policy_object_source(
138      const std::string& data) {
139    content_security_policy_object_source_ = data;
140  }
141
142  void set_content_security_policy_frame_source(
143      const std::string& data) {
144    content_security_policy_frame_source_ = data;
145  }
146
147  void set_deny_xframe_options(bool deny_xframe_options) {
148    deny_xframe_options_ = deny_xframe_options;
149  }
150
151  void set_send_content_type_header(bool send_content_type_header) {
152    send_content_type_header_ = send_content_type_header;
153  }
154
155  // Returns true when job was generated from an incognito profile.
156  bool is_incognito() const {
157    return is_incognito_;
158  }
159
160 private:
161  virtual ~URLRequestChromeJob();
162
163  // Helper for Start(), to let us start asynchronously.
164  // (This pattern is shared by most net::URLRequestJob implementations.)
165  void StartAsync(bool allowed);
166
167  // Called on the UI thread to check if this request is allowed.
168  static void CheckStoragePartitionMatches(
169      int render_process_id,
170      const GURL& url,
171      const base::WeakPtr<URLRequestChromeJob>& job);
172
173  // Do the actual copy from data_ (the data we're serving) into |buf|.
174  // Separate from ReadRawData so we can handle async I/O.
175  void CompleteRead(net::IOBuffer* buf, int buf_size, int* bytes_read);
176
177  // The actual data we're serving.  NULL until it's been fetched.
178  scoped_refptr<base::RefCountedMemory> data_;
179  // The current offset into the data that we're handing off to our
180  // callers via the Read interfaces.
181  int data_offset_;
182
183  // For async reads, we keep around a pointer to the buffer that
184  // we're reading into.
185  scoped_refptr<net::IOBuffer> pending_buf_;
186  int pending_buf_size_;
187  std::string mime_type_;
188
189  // If true, set a header in the response to prevent it from being cached.
190  bool allow_caching_;
191
192  // If true, set the Content Security Policy (CSP) header.
193  bool add_content_security_policy_;
194
195  // These are used with the CSP.
196  std::string content_security_policy_object_source_;
197  std::string content_security_policy_frame_source_;
198
199  // If true, sets  the "X-Frame-Options: DENY" header.
200  bool deny_xframe_options_;
201
202  // If true, sets the "Content-Type: <mime-type>" header.
203  bool send_content_type_header_;
204
205  // True when job is generated from an incognito profile.
206  const bool is_incognito_;
207
208  // The backend is owned by net::URLRequestContext and always outlives us.
209  URLDataManagerBackend* backend_;
210
211  base::WeakPtrFactory<URLRequestChromeJob> weak_factory_;
212
213  DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
214};
215
216URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request,
217                                         net::NetworkDelegate* network_delegate,
218                                         URLDataManagerBackend* backend,
219                                         bool is_incognito)
220    : net::URLRequestJob(request, network_delegate),
221      data_offset_(0),
222      pending_buf_size_(0),
223      allow_caching_(true),
224      add_content_security_policy_(true),
225      content_security_policy_object_source_("object-src 'none';"),
226      content_security_policy_frame_source_("frame-src 'none';"),
227      deny_xframe_options_(true),
228      send_content_type_header_(false),
229      is_incognito_(is_incognito),
230      backend_(backend),
231      weak_factory_(this) {
232  DCHECK(backend);
233}
234
235URLRequestChromeJob::~URLRequestChromeJob() {
236  CHECK(!backend_->HasPendingJob(this));
237}
238
239void URLRequestChromeJob::Start() {
240  int render_process_id, unused;
241  bool is_renderer_request = ResourceRequestInfo::GetRenderFrameForRequest(
242      request_, &render_process_id, &unused);
243  if (!is_renderer_request)
244    render_process_id = kNoRenderProcessId;
245  BrowserThread::PostTask(
246      BrowserThread::UI,
247      FROM_HERE,
248      base::Bind(&URLRequestChromeJob::CheckStoragePartitionMatches,
249                 render_process_id, request_->url(), AsWeakPtr()));
250  TRACE_EVENT_ASYNC_BEGIN1("browser", "DataManager:Request", this, "URL",
251      request_->url().possibly_invalid_spec());
252}
253
254void URLRequestChromeJob::Kill() {
255  backend_->RemoveRequest(this);
256}
257
258bool URLRequestChromeJob::GetMimeType(std::string* mime_type) const {
259  *mime_type = mime_type_;
260  return !mime_type_.empty();
261}
262
263int URLRequestChromeJob::GetResponseCode() const {
264  return net::HTTP_OK;
265}
266
267void URLRequestChromeJob::GetResponseInfo(net::HttpResponseInfo* info) {
268  DCHECK(!info->headers.get());
269  // Set the headers so that requests serviced by ChromeURLDataManager return a
270  // status code of 200. Without this they return a 0, which makes the status
271  // indistiguishable from other error types. Instant relies on getting a 200.
272  info->headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK");
273
274  // Determine the least-privileged content security policy header, if any,
275  // that is compatible with a given WebUI URL, and append it to the existing
276  // response headers.
277  if (add_content_security_policy_) {
278    std::string base = kChromeURLContentSecurityPolicyHeaderBase;
279    base.append(content_security_policy_object_source_);
280    base.append(content_security_policy_frame_source_);
281    info->headers->AddHeader(base);
282  }
283
284  if (deny_xframe_options_)
285    info->headers->AddHeader(kChromeURLXFrameOptionsHeader);
286
287  if (!allow_caching_)
288    info->headers->AddHeader("Cache-Control: no-cache");
289
290  if (send_content_type_header_ && !mime_type_.empty()) {
291    std::string content_type =
292        base::StringPrintf("%s:%s", net::HttpRequestHeaders::kContentType,
293                           mime_type_.c_str());
294    info->headers->AddHeader(content_type);
295  }
296}
297
298void URLRequestChromeJob::MimeTypeAvailable(const std::string& mime_type) {
299  set_mime_type(mime_type);
300  NotifyHeadersComplete();
301}
302
303void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
304  TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
305  if (bytes) {
306    // The request completed, and we have all the data.
307    // Clear any IO pending status.
308    SetStatus(net::URLRequestStatus());
309
310    data_ = bytes;
311    int bytes_read;
312    if (pending_buf_.get()) {
313      CHECK(pending_buf_->data());
314      CompleteRead(pending_buf_.get(), pending_buf_size_, &bytes_read);
315      pending_buf_ = NULL;
316      NotifyReadComplete(bytes_read);
317    }
318  } else {
319    // The request failed.
320    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
321                                     net::ERR_FAILED));
322  }
323}
324
325bool URLRequestChromeJob::ReadRawData(net::IOBuffer* buf, int buf_size,
326                                      int* bytes_read) {
327  if (!data_.get()) {
328    SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
329    DCHECK(!pending_buf_.get());
330    CHECK(buf->data());
331    pending_buf_ = buf;
332    pending_buf_size_ = buf_size;
333    return false;  // Tell the caller we're still waiting for data.
334  }
335
336  // Otherwise, the data is available.
337  CompleteRead(buf, buf_size, bytes_read);
338  return true;
339}
340
341void URLRequestChromeJob::CompleteRead(net::IOBuffer* buf, int buf_size,
342                                       int* bytes_read) {
343  // http://crbug.com/373841
344  char url_buf[128];
345  base::strlcpy(url_buf, request_->url().spec().c_str(), arraysize(url_buf));
346  base::debug::Alias(url_buf);
347
348  int remaining = static_cast<int>(data_->size()) - data_offset_;
349  if (buf_size > remaining)
350    buf_size = remaining;
351  if (buf_size > 0) {
352    memcpy(buf->data(), data_->front() + data_offset_, buf_size);
353    data_offset_ += buf_size;
354  }
355  *bytes_read = buf_size;
356}
357
358void URLRequestChromeJob::CheckStoragePartitionMatches(
359    int render_process_id,
360    const GURL& url,
361    const base::WeakPtr<URLRequestChromeJob>& job) {
362  // The embedder could put some webui pages in separate storage partition.
363  // RenderProcessHostImpl::IsSuitableHost would guard against top level pages
364  // being in the same process. We do an extra check to guard against an
365  // exploited renderer pretending to add them as a subframe. We skip this check
366  // for resources.
367  bool allowed = false;
368  std::vector<std::string> hosts;
369  GetContentClient()->
370      browser()->GetAdditionalWebUIHostsToIgnoreParititionCheck(&hosts);
371  if (url.SchemeIs(kChromeUIScheme) &&
372      (url.SchemeIs(kChromeUIScheme) ||
373       std::find(hosts.begin(), hosts.end(), url.host()) != hosts.end())) {
374    allowed = true;
375  } else if (render_process_id == kNoRenderProcessId) {
376    // Request was not issued by renderer.
377    allowed = true;
378  } else {
379    RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
380    if (process) {
381      StoragePartition* partition = BrowserContext::GetStoragePartitionForSite(
382          process->GetBrowserContext(), url);
383      allowed = partition == process->GetStoragePartition();
384    }
385  }
386
387  BrowserThread::PostTask(
388      BrowserThread::IO,
389      FROM_HERE,
390      base::Bind(&URLRequestChromeJob::StartAsync, job, allowed));
391}
392
393void URLRequestChromeJob::StartAsync(bool allowed) {
394  if (!request_)
395    return;
396
397  if (!allowed || !backend_->StartRequest(request_, this)) {
398    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
399                                           net::ERR_INVALID_URL));
400  }
401}
402
403namespace {
404
405// Gets mime type for data that is available from |source| by |path|.
406// After that, notifies |job| that mime type is available. This method
407// should be called on the UI thread, but notification is performed on
408// the IO thread.
409void GetMimeTypeOnUI(URLDataSourceImpl* source,
410                     const std::string& path,
411                     const base::WeakPtr<URLRequestChromeJob>& job) {
412  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
413  std::string mime_type = source->source()->GetMimeType(path);
414  BrowserThread::PostTask(
415      BrowserThread::IO, FROM_HERE,
416      base::Bind(&URLRequestChromeJob::MimeTypeAvailable, job, mime_type));
417}
418
419}  // namespace
420
421namespace {
422
423class ChromeProtocolHandler
424    : public net::URLRequestJobFactory::ProtocolHandler {
425 public:
426  // |is_incognito| should be set for incognito profiles.
427  ChromeProtocolHandler(ResourceContext* resource_context,
428                        bool is_incognito,
429                        AppCacheServiceImpl* appcache_service,
430                        ChromeBlobStorageContext* blob_storage_context)
431      : resource_context_(resource_context),
432        is_incognito_(is_incognito),
433        appcache_service_(appcache_service),
434        blob_storage_context_(blob_storage_context) {}
435  virtual ~ChromeProtocolHandler() {}
436
437  virtual net::URLRequestJob* MaybeCreateJob(
438      net::URLRequest* request,
439      net::NetworkDelegate* network_delegate) const OVERRIDE {
440    DCHECK(request);
441
442    // Check for chrome://view-http-cache/*, which uses its own job type.
443    if (ViewHttpCacheJobFactory::IsSupportedURL(request->url()))
444      return ViewHttpCacheJobFactory::CreateJobForRequest(request,
445                                                          network_delegate);
446
447    // Next check for chrome://appcache-internals/, which uses its own job type.
448    if (request->url().SchemeIs(kChromeUIScheme) &&
449        request->url().host() == kChromeUIAppCacheInternalsHost) {
450      return ViewAppCacheInternalsJobFactory::CreateJobForRequest(
451          request, network_delegate, appcache_service_);
452    }
453
454    // Next check for chrome://blob-internals/, which uses its own job type.
455    if (ViewBlobInternalsJobFactory::IsSupportedURL(request->url())) {
456      return ViewBlobInternalsJobFactory::CreateJobForRequest(
457          request, network_delegate, blob_storage_context_->context());
458    }
459
460#if defined(USE_TCMALLOC)
461    // Next check for chrome://tcmalloc/, which uses its own job type.
462    if (request->url().SchemeIs(kChromeUIScheme) &&
463        request->url().host() == kChromeUITcmallocHost) {
464      return new TcmallocInternalsRequestJob(request, network_delegate);
465    }
466#endif
467
468    // Next check for chrome://histograms/, which uses its own job type.
469    if (request->url().SchemeIs(kChromeUIScheme) &&
470        request->url().host() == kChromeUIHistogramHost) {
471      return new HistogramInternalsRequestJob(request, network_delegate);
472    }
473
474    // Fall back to using a custom handler
475    return new URLRequestChromeJob(
476        request, network_delegate,
477        GetURLDataManagerForResourceContext(resource_context_), is_incognito_);
478  }
479
480  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
481    return false;
482  }
483
484 private:
485  // These members are owned by ProfileIOData, which owns this ProtocolHandler.
486  content::ResourceContext* const resource_context_;
487
488  // True when generated from an incognito profile.
489  const bool is_incognito_;
490  AppCacheServiceImpl* appcache_service_;
491  ChromeBlobStorageContext* blob_storage_context_;
492
493  DISALLOW_COPY_AND_ASSIGN(ChromeProtocolHandler);
494};
495
496}  // namespace
497
498URLDataManagerBackend::URLDataManagerBackend()
499    : next_request_id_(0) {
500  URLDataSource* shared_source = new SharedResourcesDataSource();
501  URLDataSourceImpl* source_impl =
502      new URLDataSourceImpl(shared_source->GetSource(), shared_source);
503  AddDataSource(source_impl);
504}
505
506URLDataManagerBackend::~URLDataManagerBackend() {
507  for (DataSourceMap::iterator i = data_sources_.begin();
508       i != data_sources_.end(); ++i) {
509    i->second->backend_ = NULL;
510  }
511  data_sources_.clear();
512}
513
514// static
515net::URLRequestJobFactory::ProtocolHandler*
516URLDataManagerBackend::CreateProtocolHandler(
517    content::ResourceContext* resource_context,
518    bool is_incognito,
519    AppCacheServiceImpl* appcache_service,
520    ChromeBlobStorageContext* blob_storage_context) {
521  DCHECK(resource_context);
522  return new ChromeProtocolHandler(
523      resource_context, is_incognito, appcache_service, blob_storage_context);
524}
525
526void URLDataManagerBackend::AddDataSource(
527    URLDataSourceImpl* source) {
528  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
529  DataSourceMap::iterator i = data_sources_.find(source->source_name());
530  if (i != data_sources_.end()) {
531    if (!source->source()->ShouldReplaceExistingSource())
532      return;
533    i->second->backend_ = NULL;
534  }
535  data_sources_[source->source_name()] = source;
536  source->backend_ = this;
537}
538
539bool URLDataManagerBackend::HasPendingJob(
540    URLRequestChromeJob* job) const {
541  for (PendingRequestMap::const_iterator i = pending_requests_.begin();
542       i != pending_requests_.end(); ++i) {
543    if (i->second == job)
544      return true;
545  }
546  return false;
547}
548
549bool URLDataManagerBackend::StartRequest(const net::URLRequest* request,
550                                         URLRequestChromeJob* job) {
551  if (!CheckURLIsValid(request->url()))
552    return false;
553
554  URLDataSourceImpl* source = GetDataSourceFromURL(request->url());
555  if (!source)
556    return false;
557
558  if (!source->source()->ShouldServiceRequest(request))
559    return false;
560
561  std::string path;
562  URLToRequestPath(request->url(), &path);
563  source->source()->WillServiceRequest(request, &path);
564
565  // Save this request so we know where to send the data.
566  RequestID request_id = next_request_id_++;
567  pending_requests_.insert(std::make_pair(request_id, job));
568
569  job->set_allow_caching(source->source()->AllowCaching());
570  job->set_add_content_security_policy(
571      source->source()->ShouldAddContentSecurityPolicy());
572  job->set_content_security_policy_object_source(
573      source->source()->GetContentSecurityPolicyObjectSrc());
574  job->set_content_security_policy_frame_source(
575      source->source()->GetContentSecurityPolicyFrameSrc());
576  job->set_deny_xframe_options(
577      source->source()->ShouldDenyXFrameOptions());
578  job->set_send_content_type_header(
579      source->source()->ShouldServeMimeTypeAsContentTypeHeader());
580
581  // Look up additional request info to pass down.
582  int render_process_id = -1;
583  int render_frame_id = -1;
584  ResourceRequestInfo::GetRenderFrameForRequest(request,
585                                                &render_process_id,
586                                                &render_frame_id);
587
588  // Forward along the request to the data source.
589  base::MessageLoop* target_message_loop =
590      source->source()->MessageLoopForRequestPath(path);
591  if (!target_message_loop) {
592    job->MimeTypeAvailable(source->source()->GetMimeType(path));
593    // Eliminate potentially dangling pointer to avoid future use.
594    job = NULL;
595
596    // The DataSource is agnostic to which thread StartDataRequest is called
597    // on for this path.  Call directly into it from this thread, the IO
598    // thread.
599    source->source()->StartDataRequest(
600        path, render_process_id, render_frame_id,
601        base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
602  } else {
603    // URLRequestChromeJob should receive mime type before data. This
604    // is guaranteed because request for mime type is placed in the
605    // message loop before request for data. And correspondingly their
606    // replies are put on the IO thread in the same order.
607    target_message_loop->PostTask(
608        FROM_HERE,
609        base::Bind(&GetMimeTypeOnUI,
610                   scoped_refptr<URLDataSourceImpl>(source),
611                   path, job->AsWeakPtr()));
612
613    // The DataSource wants StartDataRequest to be called on a specific thread,
614    // usually the UI thread, for this path.
615    target_message_loop->PostTask(
616        FROM_HERE,
617        base::Bind(&URLDataManagerBackend::CallStartRequest,
618                   make_scoped_refptr(source), path, render_process_id,
619                   render_frame_id, request_id));
620  }
621  return true;
622}
623
624URLDataSourceImpl* URLDataManagerBackend::GetDataSourceFromURL(
625    const GURL& url) {
626  // The input usually looks like: chrome://source_name/extra_bits?foo
627  // so do a lookup using the host of the URL.
628  DataSourceMap::iterator i = data_sources_.find(url.host());
629  if (i != data_sources_.end())
630    return i->second.get();
631
632  // No match using the host of the URL, so do a lookup using the scheme for
633  // URLs on the form source_name://extra_bits/foo .
634  i = data_sources_.find(url.scheme() + "://");
635  if (i != data_sources_.end())
636    return i->second.get();
637
638  // No matches found, so give up.
639  return NULL;
640}
641
642void URLDataManagerBackend::CallStartRequest(
643    scoped_refptr<URLDataSourceImpl> source,
644    const std::string& path,
645    int render_process_id,
646    int render_frame_id,
647    int request_id) {
648  if (BrowserThread::CurrentlyOn(BrowserThread::UI) &&
649      render_process_id != -1 &&
650      !RenderProcessHost::FromID(render_process_id)) {
651    // Make the request fail if its initiating renderer is no longer valid.
652    // This can happen when the IO thread posts this task just before the
653    // renderer shuts down.
654    source->SendResponse(request_id, NULL);
655    return;
656  }
657  source->source()->StartDataRequest(
658      path,
659      render_process_id,
660      render_frame_id,
661      base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
662}
663
664void URLDataManagerBackend::RemoveRequest(URLRequestChromeJob* job) {
665  // Remove the request from our list of pending requests.
666  // If/when the source sends the data that was requested, the data will just
667  // be thrown away.
668  for (PendingRequestMap::iterator i = pending_requests_.begin();
669       i != pending_requests_.end(); ++i) {
670    if (i->second == job) {
671      pending_requests_.erase(i);
672      return;
673    }
674  }
675}
676
677void URLDataManagerBackend::DataAvailable(RequestID request_id,
678                                          base::RefCountedMemory* bytes) {
679  // Forward this data on to the pending net::URLRequest, if it exists.
680  PendingRequestMap::iterator i = pending_requests_.find(request_id);
681  if (i != pending_requests_.end()) {
682    URLRequestChromeJob* job(i->second);
683    pending_requests_.erase(i);
684    job->DataAvailable(bytes);
685  }
686}
687
688namespace {
689
690class DevToolsJobFactory
691    : public net::URLRequestJobFactory::ProtocolHandler {
692 public:
693  // |is_incognito| should be set for incognito profiles.
694  DevToolsJobFactory(content::ResourceContext* resource_context,
695                     bool is_incognito);
696  virtual ~DevToolsJobFactory();
697
698  virtual net::URLRequestJob* MaybeCreateJob(
699      net::URLRequest* request,
700      net::NetworkDelegate* network_delegate) const OVERRIDE;
701
702 private:
703  // |resource_context_| and |network_delegate_| are owned by ProfileIOData,
704  // which owns this ProtocolHandler.
705  content::ResourceContext* const resource_context_;
706
707  // True when generated from an incognito profile.
708  const bool is_incognito_;
709
710  DISALLOW_COPY_AND_ASSIGN(DevToolsJobFactory);
711};
712
713DevToolsJobFactory::DevToolsJobFactory(
714    content::ResourceContext* resource_context,
715    bool is_incognito)
716    : resource_context_(resource_context),
717      is_incognito_(is_incognito) {
718  DCHECK(resource_context_);
719}
720
721DevToolsJobFactory::~DevToolsJobFactory() {}
722
723net::URLRequestJob*
724DevToolsJobFactory::MaybeCreateJob(
725    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
726  return new URLRequestChromeJob(
727      request, network_delegate,
728      GetURLDataManagerForResourceContext(resource_context_), is_incognito_);
729}
730
731}  // namespace
732
733net::URLRequestJobFactory::ProtocolHandler*
734CreateDevToolsProtocolHandler(content::ResourceContext* resource_context,
735                              bool is_incognito) {
736  return new DevToolsJobFactory(resource_context, is_incognito);
737}
738
739}  // namespace content
740