content/child/npapi/plugin_stream_url.cc

   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/child/npapi/plugin_stream_url.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/strings/string_util.h"
  10 #include "content/child/npapi/plugin_host.h"
  11 #include "content/child/npapi/plugin_instance.h"
  12 #include "content/child/npapi/plugin_lib.h"
  13 #include "content/child/npapi/plugin_url_fetcher.h"
  14 #include "content/child/npapi/webplugin.h"
  15 #include "net/http/http_response_headers.h"
  16
  17 namespace content {
  18
  19 PluginStreamUrl::PluginStreamUrl(
  20     unsigned long resource_id,
  21     const GURL &url,
  22     PluginInstance *instance,
  23     bool notify_needed,
  24     void *notify_data)
  25     : PluginStream(instance, url.spec().c_str(), notify_needed, notify_data),
  26       url_(url),
  27       id_(resource_id) {
  28 }
  29
  30 void PluginStreamUrl::SetPluginURLFetcher(PluginURLFetcher* fetcher) {
  31   plugin_url_fetcher_.reset(fetcher);
  32 }
  33
  34 void PluginStreamUrl::URLRedirectResponse(bool allow) {
  35   if (plugin_url_fetcher_.get()) {
  36     plugin_url_fetcher_->URLRedirectResponse(allow);
  37   } else {
  38     instance()->webplugin()->URLRedirectResponse(allow, id_);
  39   }
  40
  41   if (allow)
  42     UpdateUrl(pending_redirect_url_.c_str());
  43 }
  44
  45 bool PluginStreamUrl::Close(NPReason reason) {
  46   // Protect the stream against it being destroyed or the whole plugin instance
  47   // being destroyed within the destroy stream handler.
  48   scoped_refptr<PluginStream> protect(this);
  49   CancelRequest();
  50   bool result = PluginStream::Close(reason);
  51   instance()->RemoveStream(this);
  52   return result;
  53 }
  54
  55 WebPluginResourceClient* PluginStreamUrl::AsResourceClient() {
  56   return static_cast<WebPluginResourceClient*>(this);
  57 }
  58
  59 void PluginStreamUrl::CancelRequest() {
  60   if (id_ > 0) {
  61     if (plugin_url_fetcher_.get()) {
  62       plugin_url_fetcher_->Cancel();
  63     } else {
  64       if (instance()->webplugin()) {
  65         instance()->webplugin()->CancelResource(id_);
  66       }
  67     }
  68     id_ = 0;
  69   }
  70   if (instance()->webplugin()) {
  71     for (size_t i = 0; i < range_requests_.size(); ++i)
  72       instance()->webplugin()->CancelResource(range_requests_[i]);
  73   }
  74   range_requests_.clear();
  75 }
  76
  77 void PluginStreamUrl::WillSendRequest(const GURL& url, int http_status_code) {
  78   if (notify_needed()) {
  79     // If the plugin participates in HTTP url redirect handling then notify it.
  80     if (net::HttpResponseHeaders::IsRedirectResponseCode(http_status_code) &&
  81         instance()->handles_url_redirects()) {
  82       pending_redirect_url_ = url.spec();
  83       instance()->NPP_URLRedirectNotify(url.spec().c_str(), http_status_code,
  84           notify_data());
  85       return;
  86     }
  87   }
  88   url_ = url;
  89   UpdateUrl(url.spec().c_str());
  90 }
  91
  92 void PluginStreamUrl::DidReceiveResponse(const std::string& mime_type,
  93                                          const std::string& headers,
  94                                          uint32 expected_length,
  95                                          uint32 last_modified,
  96                                          bool request_is_seekable) {
  97   // Protect the stream against it being destroyed or the whole plugin instance
  98   // being destroyed within the new stream handler.
  99   scoped_refptr<PluginStream> protect(this);
 100
 101   bool opened = Open(mime_type,
 102                      headers,
 103                      expected_length,
 104                      last_modified,
 105                      request_is_seekable);
 106   if (!opened) {
 107     CancelRequest();
 108     instance()->RemoveStream(this);
 109   } else {
 110     SetDeferLoading(false);
 111   }
 112 }
 113
 114 void PluginStreamUrl::DidReceiveData(const char* buffer, int length,
 115                                      int data_offset) {
 116   if (!open())
 117     return;
 118
 119   // Protect the stream against it being destroyed or the whole plugin instance
 120   // being destroyed within the write handlers
 121   scoped_refptr<PluginStream> protect(this);
 122
 123   if (length > 0) {
 124     // The PluginStreamUrl instance could get deleted if the plugin fails to
 125     // accept data in NPP_Write.
 126     if (Write(const_cast<char*>(buffer), length, data_offset) > 0) {
 127       SetDeferLoading(false);
 128     }
 129   }
 130 }
 131
 132 void PluginStreamUrl::DidFinishLoading(unsigned long resource_id) {
 133   if (!seekable()) {
 134     Close(NPRES_DONE);
 135   } else {
 136     std::vector<unsigned long>::iterator it_resource = std::find(
 137         range_requests_.begin(),
 138         range_requests_.end(),
 139         resource_id);
 140     // Resource id must be known to us - either main resource id, or one
 141     // of the resources, created for range requests.
 142     DCHECK(resource_id == id_ || it_resource != range_requests_.end());
 143     // We should notify the plugin about failed/finished requests to ensure
 144     // that the number of active resource clients does not continue to grow.
 145     if (instance()->webplugin())
 146       instance()->webplugin()->CancelResource(resource_id);
 147     if (it_resource != range_requests_.end())
 148       range_requests_.erase(it_resource);
 149   }
 150 }
 151
 152 void PluginStreamUrl::DidFail(unsigned long resource_id) {
 153   Close(NPRES_NETWORK_ERR);
 154 }
 155
 156 bool PluginStreamUrl::IsMultiByteResponseExpected() {
 157   return seekable();
 158 }
 159
 160 int PluginStreamUrl::ResourceId() {
 161   return id_;
 162 }
 163
 164 PluginStreamUrl::~PluginStreamUrl() {
 165   if (!plugin_url_fetcher_.get() && instance() && instance()->webplugin()) {
 166     instance()->webplugin()->ResourceClientDeleted(AsResourceClient());
 167   }
 168 }
 169
 170 void PluginStreamUrl::AddRangeRequestResourceId(unsigned long resource_id) {
 171   DCHECK_NE(resource_id, 0u);
 172   range_requests_.push_back(resource_id);
 173 }
 174
 175 void PluginStreamUrl::SetDeferLoading(bool value) {
 176   // If we determined that the request had failed via the HTTP headers in the
 177   // response then we send out a failure notification to the plugin process, as
 178   // certain plugins don't handle HTTP failure codes correctly.
 179   if (!value &&
 180       plugin_url_fetcher_.get() &&
 181       plugin_url_fetcher_->pending_failure_notification()) {
 182     // This object may be deleted now.
 183     DidFail(id_);
 184     return;
 185   }
 186   if (id_ > 0)
 187     instance()->webplugin()->SetDeferResourceLoading(id_, value);
 188   for (size_t i = 0; i < range_requests_.size(); ++i)
 189     instance()->webplugin()->SetDeferResourceLoading(range_requests_[i],
 190                                                      value);
 191 }
 192
 193 void PluginStreamUrl::UpdateUrl(const char* url) {
 194   DCHECK(!open());
 195   free(const_cast<char*>(stream()->url));
 196   stream()->url = base::strdup(url);
 197   pending_redirect_url_.clear();
 198 }
 199
 200 }  // namespace content