1// Copyright 2014 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/appcache/appcache_interceptor.h"
6
7#include "content/browser/appcache/appcache_backend_impl.h"
8#include "content/browser/appcache/appcache_host.h"
9#include "content/browser/appcache/appcache_request_handler.h"
10#include "content/browser/appcache/appcache_service_impl.h"
11#include "content/browser/appcache/appcache_url_request_job.h"
12#include "content/common/appcache_interfaces.h"
13
14namespace content {
15
16// static
17AppCacheInterceptor* AppCacheInterceptor::GetInstance() {
18  return Singleton<AppCacheInterceptor>::get();
19}
20
21void AppCacheInterceptor::SetHandler(net::URLRequest* request,
22                                     AppCacheRequestHandler* handler) {
23  request->SetUserData(GetInstance(), handler);  // request takes ownership
24}
25
26AppCacheRequestHandler* AppCacheInterceptor::GetHandler(
27    net::URLRequest* request) {
28  return reinterpret_cast<AppCacheRequestHandler*>(
29      request->GetUserData(GetInstance()));
30}
31
32void AppCacheInterceptor::SetExtraRequestInfo(
33    net::URLRequest* request,
34    AppCacheServiceImpl* service,
35    int process_id,
36    int host_id,
37    ResourceType resource_type) {
38  if (!service || (host_id == kAppCacheNoHostId))
39    return;
40
41  AppCacheBackendImpl* backend = service->GetBackend(process_id);
42  if (!backend)
43    return;
44
45  // TODO(michaeln): An invalid host id is indicative of bad data
46  // from a child process. How should we handle that here?
47  AppCacheHost* host = backend->GetHost(host_id);
48  if (!host)
49    return;
50
51  // Create a handler for this request and associate it with the request.
52  AppCacheRequestHandler* handler =
53      host->CreateRequestHandler(request, resource_type);
54  if (handler)
55    SetHandler(request, handler);
56}
57
58void AppCacheInterceptor::GetExtraResponseInfo(net::URLRequest* request,
59                                               int64* cache_id,
60                                               GURL* manifest_url) {
61  DCHECK(*cache_id == kAppCacheNoCacheId);
62  DCHECK(manifest_url->is_empty());
63  AppCacheRequestHandler* handler = GetHandler(request);
64  if (handler)
65    handler->GetExtraResponseInfo(cache_id, manifest_url);
66}
67
68void AppCacheInterceptor::PrepareForCrossSiteTransfer(
69    net::URLRequest* request,
70    int old_process_id) {
71  AppCacheRequestHandler* handler = GetHandler(request);
72  if (!handler)
73    return;
74  handler->PrepareForCrossSiteTransfer(old_process_id);
75}
76
77void AppCacheInterceptor::CompleteCrossSiteTransfer(
78    net::URLRequest* request,
79    int new_process_id,
80    int new_host_id) {
81  AppCacheRequestHandler* handler = GetHandler(request);
82  if (!handler)
83    return;
84  DCHECK_NE(kAppCacheNoHostId, new_host_id);
85  handler->CompleteCrossSiteTransfer(new_process_id,
86                                     new_host_id);
87}
88
89AppCacheInterceptor::AppCacheInterceptor() {
90  net::URLRequest::Deprecated::RegisterRequestInterceptor(this);
91}
92
93AppCacheInterceptor::~AppCacheInterceptor() {
94  net::URLRequest::Deprecated::UnregisterRequestInterceptor(this);
95}
96
97net::URLRequestJob* AppCacheInterceptor::MaybeIntercept(
98    net::URLRequest* request, net::NetworkDelegate* network_delegate) {
99  AppCacheRequestHandler* handler = GetHandler(request);
100  if (!handler)
101    return NULL;
102  return handler->MaybeLoadResource(request, network_delegate);
103}
104
105net::URLRequestJob* AppCacheInterceptor::MaybeInterceptRedirect(
106    net::URLRequest* request,
107    net::NetworkDelegate* network_delegate,
108    const GURL& location) {
109  AppCacheRequestHandler* handler = GetHandler(request);
110  if (!handler)
111    return NULL;
112  return handler->MaybeLoadFallbackForRedirect(
113      request, network_delegate, location);
114}
115
116net::URLRequestJob* AppCacheInterceptor::MaybeInterceptResponse(
117    net::URLRequest* request, net::NetworkDelegate* network_delegate) {
118  AppCacheRequestHandler* handler = GetHandler(request);
119  if (!handler)
120    return NULL;
121  return handler->MaybeLoadFallbackForResponse(request, network_delegate);
122}
123
124}  // namespace content
125