This CB fixes the following issues:-...

webkit/glue/plugins/plugin_instance.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 "webkit/glue/plugins/plugin_instance.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/thread_local_storage.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/webkit_glue.h"
-#include "webkit/glue/plugins/plugin_data_stream.h"
 #include "webkit/glue/plugins/plugin_host.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/plugins/plugin_stream_url.h"
 #include "webkit/glue/plugins/plugin_string_stream.h"
 #include "webkit/glue/plugins/mozilla_extensions.h"
 #include "net/base/escape.h"
 
 namespace NPAPI
 {
 
@@ skipping 62 matching lines @@
 void PluginInstance::AddStream(PluginStream* stream) {
   open_streams_.push_back(stream);
 }
 
 void PluginInstance::RemoveStream(PluginStream* stream) {
   if (in_close_streams_)
     return;
 
   std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
   for (stream_index = open_streams_.begin();
-          stream_index != open_streams_.end(); ++stream_index) {
+       stream_index != open_streams_.end(); ++stream_index) {
     if (*stream_index == stream) {
       open_streams_.erase(stream_index);
       break;
     }
   }
 }
 
 bool PluginInstance::IsValidStream(const NPStream* stream) {
   std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
   for (stream_index = open_streams_.begin();
@@ skipping 242 matching lines @@
                                               const std::string& mime_type,
                                               const std::string& headers,
                                               uint32 expected_length,
                                               uint32 last_modified) {
   DCHECK(load_manually_);
   std::string response_url = url;
   if (response_url.empty()) {
     response_url = instance_url_.spec();
   }
 
-  plugin_data_stream_ = new PluginDataStream(this, response_url, mime_type,
-                                             headers, expected_length,
-                                             last_modified);
+  bool cancel = false;
+
+  plugin_data_stream_ = CreateStream(-1, url, mime_type, false, NULL);
+
+  plugin_data_stream_->DidReceiveResponse(mime_type, headers, expected_length,
+                                          last_modified, &cancel);
   AddStream(plugin_data_stream_.get());
 }
 
 void PluginInstance::DidReceiveManualData(const char* buffer, int length) {
   DCHECK(load_manually_);
-  DCHECK(plugin_data_stream_.get() != NULL);
-  plugin_data_stream_->SendToPlugin(buffer, length);
+  if (plugin_data_stream_.get() != NULL) {
+    plugin_data_stream_->DidReceiveData(buffer, length, 0);
+  }
 }
 
 void PluginInstance::DidFinishManualLoading() {
   DCHECK(load_manually_);
-  DCHECK(plugin_data_stream_);
-  plugin_data_stream_->Close(NPRES_DONE);
-  RemoveStream(plugin_data_stream_.get());
-  plugin_data_stream_ = NULL;
+  if (plugin_data_stream_.get() != NULL) {
+    plugin_data_stream_->DidFinishLoading();
+    plugin_data_stream_->Close(NPRES_DONE);
+    plugin_data_stream_ = NULL;
+  }
 }
 
 void PluginInstance::DidManualLoadFail() {
   DCHECK(load_manually_);
-  DCHECK(plugin_data_stream_);
-  plugin_data_stream_->Close(NPRES_NETWORK_ERR);
-  RemoveStream(plugin_data_stream_.get());
-  plugin_data_stream_ = NULL;
+  if (plugin_data_stream_.get() != NULL) {
+    plugin_data_stream_->DidFail();
+    plugin_data_stream_ = NULL;
+  }
 }
 
 void PluginInstance::PluginThreadAsyncCall(void (*func)(void *),
                                            void *userData) {
   message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
       this, &PluginInstance::OnPluginThreadAsyncCall, func, userData));
 }
 
 void PluginInstance::OnPluginThreadAsyncCall(void (*func)(void *),
                                              void *userData) {
@@ skipping 34 matching lines @@
 }
 
 void PluginInstance::PushPopupsEnabledState(bool enabled) {
   popups_enabled_stack_.push(enabled);
 }
 
 void PluginInstance::PopPopupsEnabledState() {
   popups_enabled_stack_.pop();
 }
 
+void PluginInstance::RequestRead(NPStream* stream, NPByteRange* range_list) {
+  std::string range_info = "bytes=";
+
+  while (range_list) {
+    range_info += IntToString(range_list->offset);
+    range_info += "-";
+    range_info += IntToString(range_list->offset + range_list->length - 1);
+    range_list = range_list->next;
+    if (range_list) {
+      range_info += ",";
+    }
+  }
+
+  if (plugin_data_stream_) {
+    if (plugin_data_stream_->stream() == stream) {
+      webplugin_->CancelDocumentLoad();
+      plugin_data_stream_ = NULL;
+    }
+  }
+
+  // The lifetime of a NPStream instance depends on the PluginStream instance
+  // which owns it. When a plugin invokes NPN_RequestRead on a seekable stream,
+  // we don't want to create a new stream when the corresponding response is
+  // received. We send over a cookie which represents the PluginStream
+  // instance which is sent back from the renderer when the response is
+  // received.
+  std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
+  for (stream_index = open_streams_.begin();
+          stream_index != open_streams_.end(); ++stream_index) {
+    PluginStream* plugin_stream = *stream_index;
+    if (plugin_stream->stream() == stream) {
+      // A stream becomes seekable the first time NPN_RequestRead
+      // is called on it.
+      plugin_stream->set_seekable(true);
+
+      webplugin_->InitiateHTTPRangeRequest(
+          stream->url, range_info.c_str(),
+          plugin_stream,
+          plugin_stream->notify_needed(), 
+          plugin_stream->notify_data());
+      break;
+    }
+  }
+}
+
 }  // namespace NPAPI