src/third_party/WebKit/Source/core/fetch/RawResource.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All Rights Reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "core/fetch/RawResource.h"
  28
  29 #include "core/fetch/ResourceClientWalker.h"
  30 #include "core/fetch/ResourceFetcher.h"
  31 #include "core/fetch/ResourceLoader.h"
  32 #include "platform/SharedBuffer.h"
  33
  34 namespace WebCore {
  35
  36 RawResource::RawResource(const ResourceRequest& resourceRequest, Type type)
  37     : Resource(resourceRequest, type)
  38 {
  39 }
  40
  41 void RawResource::appendData(const char* data, int length)
  42 {
  43     Resource::appendData(data, length);
  44
  45     ResourcePtr<RawResource> protect(this);
  46     ResourceClientWalker<RawResourceClient> w(m_clients);
  47     while (RawResourceClient* c = w.next())
  48         c->dataReceived(this, data, length);
  49 }
  50
  51 void RawResource::didAddClient(ResourceClient* c)
  52 {
  53     if (!hasClient(c))
  54         return;
  55     // The calls to the client can result in events running, potentially causing
  56     // this resource to be evicted from the cache and all clients to be removed,
  57     // so a protector is necessary.
  58     ResourcePtr<RawResource> protect(this);
  59     RawResourceClient* client = static_cast<RawResourceClient*>(c);
  60     size_t redirectCount = m_redirectChain.size();
  61     for (size_t i = 0; i < redirectCount; i++) {
  62         RedirectPair redirect = m_redirectChain[i];
  63         ResourceRequest request(redirect.m_request);
  64         client->redirectReceived(this, request, redirect.m_redirectResponse);
  65         if (!hasClient(c))
  66             return;
  67     }
  68     ASSERT(redirectCount == m_redirectChain.size());
  69
  70     if (!m_response.isNull())
  71         client->responseReceived(this, m_response);
  72     if (!hasClient(c))
  73         return;
  74     if (m_data)
  75         client->dataReceived(this, m_data->data(), m_data->size());
  76     if (!hasClient(c))
  77         return;
  78     Resource::didAddClient(client);
  79 }
  80
  81 void RawResource::willSendRequest(ResourceRequest& request, const ResourceResponse& response)
  82 {
  83     ResourcePtr<RawResource> protect(this);
  84     if (!response.isNull()) {
  85         ResourceClientWalker<RawResourceClient> w(m_clients);
  86         while (RawResourceClient* c = w.next())
  87             c->redirectReceived(this, request, response);
  88         m_redirectChain.append(RedirectPair(request, response));
  89     }
  90     Resource::willSendRequest(request, response);
  91 }
  92
  93 void RawResource::updateRequest(const ResourceRequest& request)
  94 {
  95     ResourcePtr<RawResource> protect(this);
  96     ResourceClientWalker<RawResourceClient> w(m_clients);
  97     while (RawResourceClient* c = w.next())
  98         c->updateRequest(this, request);
  99 }
 100
 101 void RawResource::responseReceived(const ResourceResponse& response)
 102 {
 103     InternalResourcePtr protect(this);
 104     Resource::responseReceived(response);
 105     ResourceClientWalker<RawResourceClient> w(m_clients);
 106     while (RawResourceClient* c = w.next())
 107         c->responseReceived(this, m_response);
 108 }
 109
 110 void RawResource::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 111 {
 112     ResourceClientWalker<RawResourceClient> w(m_clients);
 113     while (RawResourceClient* c = w.next())
 114         c->dataSent(this, bytesSent, totalBytesToBeSent);
 115 }
 116
 117 void RawResource::didDownloadData(int dataLength)
 118 {
 119     ResourceClientWalker<RawResourceClient> w(m_clients);
 120     while (RawResourceClient* c = w.next())
 121         c->dataDownloaded(this, dataLength);
 122 }
 123
 124 void RawResource::setDefersLoading(bool defers)
 125 {
 126     if (m_loader)
 127         m_loader->setDefersLoading(defers);
 128 }
 129
 130 static bool shouldIgnoreHeaderForCacheReuse(AtomicString headerName)
 131 {
 132     // FIXME: This list of headers that don't affect cache policy almost certainly isn't complete.
 133     DEFINE_STATIC_LOCAL(HashSet<AtomicString>, m_headers, ());
 134     if (m_headers.isEmpty()) {
 135         m_headers.add("Cache-Control");
 136         m_headers.add("If-Modified-Since");
 137         m_headers.add("If-None-Match");
 138         m_headers.add("Origin");
 139         m_headers.add("Pragma");
 140         m_headers.add("Purpose");
 141         m_headers.add("Referer");
 142         m_headers.add("User-Agent");
 143     }
 144     return m_headers.contains(headerName);
 145 }
 146
 147 bool RawResource::canReuse(const ResourceRequest& newRequest) const
 148 {
 149     if (m_options.dataBufferingPolicy == DoNotBufferData)
 150         return false;
 151
 152     if (m_resourceRequest.httpMethod() != newRequest.httpMethod())
 153         return false;
 154
 155     if (m_resourceRequest.httpBody() != newRequest.httpBody())
 156         return false;
 157
 158     if (m_resourceRequest.allowCookies() != newRequest.allowCookies())
 159         return false;
 160
 161     // Ensure most headers match the existing headers before continuing.
 162     // Note that the list of ignored headers includes some headers explicitly related to caching.
 163     // A more detailed check of caching policy will be performed later, this is simply a list of
 164     // headers that we might permit to be different and still reuse the existing Resource.
 165     const HTTPHeaderMap& newHeaders = newRequest.httpHeaderFields();
 166     const HTTPHeaderMap& oldHeaders = m_resourceRequest.httpHeaderFields();
 167
 168     HTTPHeaderMap::const_iterator end = newHeaders.end();
 169     for (HTTPHeaderMap::const_iterator i = newHeaders.begin(); i != end; ++i) {
 170         AtomicString headerName = i->key;
 171         if (!shouldIgnoreHeaderForCacheReuse(headerName) && i->value != oldHeaders.get(headerName))
 172             return false;
 173     }
 174
 175     end = oldHeaders.end();
 176     for (HTTPHeaderMap::const_iterator i = oldHeaders.begin(); i != end; ++i) {
 177         AtomicString headerName = i->key;
 178         if (!shouldIgnoreHeaderForCacheReuse(headerName) && i->value != newHeaders.get(headerName))
 179             return false;
 180     }
 181
 182     for (size_t i = 0; i < m_redirectChain.size(); i++) {
 183         if (m_redirectChain[i].m_redirectResponse.cacheControlContainsNoStore())
 184             return false;
 185     }
 186
 187     return true;
 188 }
 189
 190 } // namespace WebCore