Home | History | Annotate | Download | only in fetch 
      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 blink {
     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 = redirectChain().size();
     61     for (size_t i = 0; i < redirectCount; i++) {
     62         RedirectPair redirect = 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 == 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     }
     89     Resource::willSendRequest(request, response);
     90 }
     91 
     92 void RawResource::updateRequest(const ResourceRequest& request)
     93 {
     94     ResourcePtr<RawResource> protect(this);
     95     ResourceClientWalker<RawResourceClient> w(m_clients);
     96     while (RawResourceClient* c = w.next())
     97         c->updateRequest(this, request);
     98 }
     99 
    100 void RawResource::responseReceived(const ResourceResponse& response)
    101 {
    102     InternalResourcePtr protect(this);
    103     Resource::responseReceived(response);
    104     ResourceClientWalker<RawResourceClient> w(m_clients);
    105     while (RawResourceClient* c = w.next())
    106         c->responseReceived(this, m_response);
    107 }
    108 
    109 void RawResource::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
    110 {
    111     ResourceClientWalker<RawResourceClient> w(m_clients);
    112     while (RawResourceClient* c = w.next())
    113         c->dataSent(this, bytesSent, totalBytesToBeSent);
    114 }
    115 
    116 void RawResource::didDownloadData(int dataLength)
    117 {
    118     ResourceClientWalker<RawResourceClient> w(m_clients);
    119     while (RawResourceClient* c = w.next())
    120         c->dataDownloaded(this, dataLength);
    121 }
    122 
    123 void RawResource::setDefersLoading(bool defers)
    124 {
    125     if (m_loader)
    126         m_loader->setDefersLoading(defers);
    127 }
    128 
    129 static bool shouldIgnoreHeaderForCacheReuse(AtomicString headerName)
    130 {
    131     // FIXME: This list of headers that don't affect cache policy almost certainly isn't complete.
    132     DEFINE_STATIC_LOCAL(HashSet<AtomicString>, m_headers, ());
    133     if (m_headers.isEmpty()) {
    134         m_headers.add("Cache-Control");
    135         m_headers.add("If-Modified-Since");
    136         m_headers.add("If-None-Match");
    137         m_headers.add("Origin");
    138         m_headers.add("Pragma");
    139         m_headers.add("Purpose");
    140         m_headers.add("Referer");
    141         m_headers.add("User-Agent");
    142     }
    143     return m_headers.contains(headerName);
    144 }
    145 
    146 static bool isCacheableHTTPMethod(const AtomicString& method)
    147 {
    148     // Per http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.10,
    149     // these methods always invalidate the cache entry.
    150     return method != "POST" && method != "PUT" && method != "DELETE";
    151 }
    152 
    153 bool RawResource::canReuse(const ResourceRequest& newRequest) const
    154 {
    155     if (m_options.dataBufferingPolicy == DoNotBufferData)
    156         return false;
    157 
    158     if (!isCacheableHTTPMethod(m_resourceRequest.httpMethod()))
    159         return false;
    160     if (m_resourceRequest.httpMethod() != newRequest.httpMethod())
    161         return false;
    162 
    163     if (m_resourceRequest.httpBody() != newRequest.httpBody())
    164         return false;
    165 
    166     if (m_resourceRequest.allowStoredCredentials() != newRequest.allowStoredCredentials())
    167         return false;
    168 
    169     // Ensure most headers match the existing headers before continuing.
    170     // Note that the list of ignored headers includes some headers explicitly related to caching.
    171     // A more detailed check of caching policy will be performed later, this is simply a list of
    172     // headers that we might permit to be different and still reuse the existing Resource.
    173     const HTTPHeaderMap& newHeaders = newRequest.httpHeaderFields();
    174     const HTTPHeaderMap& oldHeaders = m_resourceRequest.httpHeaderFields();
    175 
    176     HTTPHeaderMap::const_iterator end = newHeaders.end();
    177     for (HTTPHeaderMap::const_iterator i = newHeaders.begin(); i != end; ++i) {
    178         AtomicString headerName = i->key;
    179         if (!shouldIgnoreHeaderForCacheReuse(headerName) && i->value != oldHeaders.get(headerName))
    180             return false;
    181     }
    182 
    183     end = oldHeaders.end();
    184     for (HTTPHeaderMap::const_iterator i = oldHeaders.begin(); i != end; ++i) {
    185         AtomicString headerName = i->key;
    186         if (!shouldIgnoreHeaderForCacheReuse(headerName) && i->value != newHeaders.get(headerName))
    187             return false;
    188     }
    189 
    190     return true;
    191 }
    192 
    193 } // namespace blink
    194