This CB fixes the following issues:-...

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 26 matching lines @@
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
       notify_needed_(false), notify_data_(NULL) {
   }
 
   ~ResourceClientProxy() {
   }
 
   void Initialize(int resource_id, const std::string &url, bool notify_needed,
-                  void *notify_data) {
+                  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;
 
     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));
   }
@@ skipping 10 matching lines @@
     params.headers = headers;
     params.expected_length = expected_length;
     params.last_modified = last_modified;
     // 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) {
+  void DidReceiveData(const char* buffer, int length, int data_offset) {
     DCHECK(channel_ != NULL);
     DCHECK(length > 0);
     std::vector<char> data;
     data.resize(static_cast<size_t>(length));
     memcpy(&data.front(), buffer, length);
     // 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_DidReceiveData(instance_id_, resource_id_,
-                                                data));
+                                                data, data_offset));
   }
 
   void DidFinishLoading() {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_DidFinishLoading(instance_id_, resource_id_));
     channel_ = NULL;
     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);
   }
 
- private:
+private:
   int resource_id_;
   int instance_id_;
   scoped_refptr<PluginChannelHost> channel_;
   std::string url_;
   bool notify_needed_;
   void* notify_data_;
 };
 
 WebPluginDelegateProxy* WebPluginDelegateProxy::Create(
     const GURL& url,
@@ skipping 183 matching lines @@
                         OnGetPluginElement)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies)
     IPC_MESSAGE_HANDLER(PluginHostMsg_ShowModalHTMLDialog,
                         OnShowModalHTMLDialog)
     IPC_MESSAGE_HANDLER(PluginHostMsg_MissingPluginStatus,
                         OnMissingPluginStatus)
     IPC_MESSAGE_HANDLER(PluginHostMsg_URLRequest, OnHandleURLRequest)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCPBrowsingContext,
                         OnGetCPBrowsingContext)
+    IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad)
+    IPC_MESSAGE_HANDLER(PluginHostMsg_InitiateHTTPRangeRequest,
+                        OnInitiateHTTPRangeRequest)
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }
 
 void WebPluginDelegateProxy::OnChannelError() {
   OnInvalidate();
   render_view_->PluginCrashed(plugin_path_);
 }
 
 void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect,
@@ skipping 319 matching lines @@
   plugin_->HandleURLRequest(params.method.c_str(),
                             params.is_javascript_url, target,
                             static_cast<unsigned int>(params.buffer.size()),
                             data, params.is_file_data, params.notify,
                             params.url.c_str(), params.notify_data,
                             params.popups_allowed);
 }
 
 WebPluginResourceClient* WebPluginDelegateProxy::CreateResourceClient(
     int resource_id, const std::string &url, bool notify_needed,
-    void *notify_data) {
+    void* notify_data, void* npstream) {
   ResourceClientProxy* proxy = new ResourceClientProxy(channel_host_,
                                                        instance_id_);
-  proxy->Initialize(resource_id, url, notify_needed, notify_data);
+  proxy->Initialize(resource_id, url, notify_needed, notify_data, npstream);
   return proxy;
 }
 
 void WebPluginDelegateProxy::URLRequestRouted(const std::string& url,
                                                bool notify_needed,
                                                void* notify_data) {
   Send(new PluginMsg_URLRequestRouted(instance_id_, url, notify_needed,
                                       notify_data));
 }
 
+void WebPluginDelegateProxy::OnCancelDocumentLoad() {
+  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);
+}