Handle HTTP 200 responses received in response to byte range requests issued...

chrome/renderer/webplugin_delegate_proxy.cc

 // Copyright (c) 2006-2008 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 "chrome/renderer/webplugin_delegate_proxy.h"
 
 #include <atlbase.h>
 
 #include "generated_resources.h"
 
@@ skipping 19 matching lines @@
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/webview.h"
 
 // Proxy for WebPluginResourceClient.  The object owns itself after creation,
 // deleting itself after its callback has been called.
 class ResourceClientProxy : public WebPluginResourceClient {
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
-      notify_needed_(false), notify_data_(NULL) {
+      notify_needed_(false), notify_data_(NULL),
+      multibyte_response_expected_(false) {
   }
 
   ~ResourceClientProxy() {
   }
 
   void Initialize(int resource_id, const std::string &url, bool notify_needed,
                   void *notify_data, void* existing_stream) {
     resource_id_ = resource_id;
     url_ = url;
     notify_needed_ = notify_needed;
     notify_data_ = notify_data;
 
     PluginMsg_URLRequestReply_Params params;
     params.resource_id = resource_id;
     params.url = url_;
     params.notify_needed = notify_needed_;
     params.notify_data = notify_data_;
     params.stream = existing_stream;
 
+    multibyte_response_expected_ = (existing_stream != NULL);
+
     channel_->Send(new PluginMsg_HandleURLRequestReply(instance_id_, params));
   }
 
   // PluginResourceClient implementation:
   void WillSendRequest(const GURL& url) {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_WillSendRequest(instance_id_, resource_id_,
                                                  url));
   }
 
   void DidReceiveResponse(const std::string& mime_type,
                           const std::string& headers,
                           uint32 expected_length,
                           uint32 last_modified,
+                          bool request_is_seekable,
                           bool* cancel) {
     DCHECK(channel_ != NULL);
     PluginMsg_DidReceiveResponseParams params;
     params.id = resource_id_;
     params.mime_type = mime_type;
     params.headers = headers;
     params.expected_length = expected_length;
     params.last_modified = last_modified;
+    params.request_is_seekable = request_is_seekable;
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveResponse(instance_id_, params,
                                                     cancel));
   }
 
   void DidReceiveData(const char* buffer, int length, int data_offset) {
     DCHECK(channel_ != NULL);
     DCHECK(length > 0);
@@ skipping 14 matching lines @@
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
   void DidFail() {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_));
     channel_ = NULL;
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
+  bool IsMultiByteResponseExpected() {
+    return multibyte_response_expected_;
+  }
+
 private:
   int resource_id_;
   int instance_id_;
   scoped_refptr<PluginChannelHost> channel_;
   std::string url_;
   bool notify_needed_;
   void* notify_data_;
+  // Set to true if the response expected is a multibyte response.
+  // For e.g. response for a HTTP byte range request.
+  bool multibyte_response_expected_;
 };
 
 WebPluginDelegateProxy* WebPluginDelegateProxy::Create(
     const GURL& url,
     const std::string& mime_type,
     const std::string& clsid,
     RenderView* render_view) {
   return new WebPluginDelegateProxy(mime_type, clsid, render_view);
 }
 
@@ skipping 606 matching lines @@
   plugin_->CancelDocumentLoad();
 }
 
 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
    const std::string& url, const std::string& range_info,
    HANDLE existing_stream, bool notify_needed, HANDLE notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }