Support byte range requests when routing resource requests directly through the browser process.

content/renderer/npapi/webplugin_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/npapi/webplugin_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
@@ skipping 78 matching lines @@
 
 namespace {
 
 // This class handles individual multipart responses. It is instantiated when
 // we receive HTTP status code 206 in the HTTP response. This indicates
 // that the response could have multiple parts each separated by a boundary
 // specified in the response header.
 class MultiPartResponseClient : public WebURLLoaderClient {
  public:
   explicit MultiPartResponseClient(WebPluginResourceClient* resource_client)
-      : resource_client_(resource_client) {
-    Clear();
-  }
+      : byte_range_lower_bound_(0), resource_client_(resource_client) {}
 
   virtual void willSendRequest(
       WebURLLoader*, WebURLRequest&, const WebURLResponse&) {}
   virtual void didSendData(
       WebURLLoader*, unsigned long long, unsigned long long) {}
 
   // Called when the multipart parser encounters an embedded multipart
   // response.
   virtual void didReceiveResponse(
       WebURLLoader*, const WebURLResponse& response) {
-    int64 instance_size;
+    int64 byte_range_upper_bound, instance_size;
     if (!MultipartResponseDelegate::ReadContentRanges(
             response,
             &byte_range_lower_bound_,
-            &byte_range_upper_bound_,
+            &byte_range_upper_bound,
             &instance_size)) {
       NOTREACHED();
-      return;
     }
-
-    resource_response_ = response;
   }
 
   // Receives individual part data from a multipart response.
   virtual void didReceiveData(WebURLLoader*,
                               const char* data,
                               int data_length,
                               int encoded_data_length) {
     // TODO(ananta)
     // We should defer further loads on multipart resources on the same lines
     // as regular resources requested by plugins to prevent reentrancy.
     resource_client_->DidReceiveData(
         data, data_length, byte_range_lower_bound_);
     byte_range_lower_bound_ += data_length;
   }
 
   virtual void didFinishLoading(WebURLLoader*, double finishTime) {}
   virtual void didFail(WebURLLoader*, const WebURLError&) {}
 
-  void Clear() {
-    resource_response_.reset();
-    byte_range_lower_bound_ = 0;
-    byte_range_upper_bound_ = 0;
-  }
-
  private:
-  WebURLResponse resource_response_;
   // The lower bound of the byte range.
   int64 byte_range_lower_bound_;
-  // The upper bound of the byte range.
-  int64 byte_range_upper_bound_;
   // The handler for the data.
   WebPluginResourceClient* resource_client_;
 };
 
 class HeaderFlattener : public WebHTTPHeaderVisitor {
  public:
   explicit HeaderFlattener(std::string* buf) : buf_(buf) {
   }
 
   virtual void visitHeader(const WebString& name, const WebString& value) {
@@ skipping 777 matching lines @@
   }
 }
 
 void WebPluginImpl::didSendData(WebURLLoader* loader,
                                 unsigned long long bytes_sent,
                                 unsigned long long total_bytes_to_be_sent) {
 }
 
 void WebPluginImpl::didReceiveResponse(WebURLLoader* loader,
                                        const WebURLResponse& response) {
+  // TODO(jam): THIS LOGIC IS COPIED IN PluginURLFetcher::OnReceivedResponse
+  // until kDirectNPAPIRequests is the default and we can remove this old path.
   static const int kHttpPartialResponseStatusCode = 206;
   static const int kHttpResponseSuccessStatusCode = 200;
 
   WebPluginResourceClient* client = GetClientFromLoader(loader);
   if (!client)
     return;
 
   ResponseInfo response_info;
   GetResponseInfo(response, &response_info);
   ClientInfo* client_info = GetClientInfoFromLoader(loader);
@@ skipping 114 matching lines @@
 }
 
 void WebPluginImpl::didFinishLoading(WebURLLoader* loader, double finishTime) {
   ClientInfo* client_info = GetClientInfoFromLoader(loader);
   if (client_info && client_info->client) {
     MultiPartResponseHandlerMap::iterator index =
       multi_part_response_map_.find(client_info->client);
     if (index != multi_part_response_map_.end()) {
       delete (*index).second;
       multi_part_response_map_.erase(index);
-      if (render_view_.get()) {
-        // TODO(darin): Make is_loading_ be a counter!
-        render_view_->didStopLoading();
-      }
+      DidStopLoading();
     }
     loader->setDefersLoading(true);
     WebPluginResourceClient* resource_client = client_info->client;
     // The ClientInfo can get deleted in the call to DidFinishLoading below.
     // It is not safe to access this structure after that.
     client_info->client = NULL;
     resource_client->DidFinishLoading(client_info->id);
   }
 }
 
@@ skipping 123 matching lines @@
     // TODO(jam): any better way of getting this? Can't find a way to get
     // frame()->loader()->outgoingReferrer() which
     // WebFrameImpl::setReferrerForRequest does.
     WebURLRequest request(complete_url);
     SetReferrer(&request, referrer_flag);
     GURL referrer(
         request.httpHeaderField(WebString::fromUTF8("Referer")).utf8());
 
     GURL first_party_for_cookies = webframe_->document().firstPartyForCookies();
     delegate_->FetchURL(resource_id, notify_id, complete_url,
-                        first_party_for_cookies, method, std::string(buf, len),
-                        referrer, notify_redirects, is_plugin_src_load, 0,
+                        first_party_for_cookies, method, buf, len, referrer,
+                        notify_redirects, is_plugin_src_load, 0,
                         render_view_->routing_id());
   } else {
     WebPluginResourceClient* resource_client = delegate_->CreateResourceClient(
         resource_id, complete_url, notify_id);
     if (!resource_client)
       return;
     InitiateHTTPRequest(resource_id, resource_client, complete_url, method, buf,
                         len, NULL, referrer_flag, notify_redirects,
                         is_plugin_src_load);
   }
@@ skipping 83 matching lines @@
                                  load_manually_ ? NO_REFERRER : PLUGIN_SRC))
     return;
 
   WebPluginResourceClient* resource_client =
       delegate_->CreateSeekableResourceClient(resource_id, range_request_id);
   InitiateHTTPRequest(
       resource_id, resource_client, complete_url, "GET", NULL, 0, range_info,
       load_manually_ ? NO_REFERRER : PLUGIN_SRC, false, false);
 }
 
+void WebPluginImpl::DidStartLoading() {
+  if (render_view_.get()) {
+    // TODO(darin): Make is_loading_ be a counter!
+    render_view_->didStartLoading();
+  }
+}
+
+void WebPluginImpl::DidStopLoading() {
+  if (render_view_.get()) {
+    // TODO(darin): Make is_loading_ be a counter!
+    render_view_->didStopLoading();
+  }
+}
+
 void WebPluginImpl::SetDeferResourceLoading(unsigned long resource_id,
                                             bool defer) {
   std::vector<ClientInfo>::iterator client_index = clients_.begin();
   while (client_index != clients_.end()) {
     ClientInfo& client_info = *client_index;
 
     if (client_info.id == resource_id) {
       client_info.loader->setDefersLoading(defer);
 
       // If we determined that the request had failed via the HTTP headers
@@ skipping 20 matching lines @@
 }
 
 bool WebPluginImpl::HandleHttpMultipartResponse(
     const WebURLResponse& response, WebPluginResourceClient* client) {
   std::string multipart_boundary;
   if (!MultipartResponseDelegate::ReadMultipartBoundary(
           response, &multipart_boundary)) {
     return false;
   }
 
-  if (render_view_.get()) {
-    // TODO(darin): Make is_loading_ be a counter!
-    render_view_->didStartLoading();
-  }
+  DidStartLoading();
 
   MultiPartResponseClient* multi_part_response_client =
       new MultiPartResponseClient(client);
 
   MultipartResponseDelegate* multi_part_response_handler =
       new MultipartResponseDelegate(multi_part_response_client, NULL,
                                     response,
                                     multipart_boundary);
   multi_part_response_map_[client] = multi_part_response_handler;
   return true;
@@ skipping 111 matching lines @@
     case PLUGIN_SRC:
       webframe_->setReferrerForRequest(*request, plugin_url_);
       break;
 
     default:
       break;
   }
 }
 
 }  // namespace content