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

webkit/glue/webplugin_impl.h

 // 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.
 
 #ifndef WEBKIT_GLUE_WEBPLUGIN_IMPL_H_
 #define WEBKIT_GLUE_WEBPLUGIN_IMPL_H_
 
 #include <string>
 #include <map>
 #include <vector>
@@ skipping 106 matching lines @@
   // Creates a WebPlugin instance, as long as the delegate's initialization
   // succeeds.  If it fails, the delegate is deleted and NULL is returned.
   // Note that argn and argv are UTF8.
   static WebCore::Widget* Create(const GURL& url,
                                  char** argn,
                                  char** argv,
                                  int argc,
                                  WebCore::Element* element,
                                  WebFrameImpl* frame,
                                  WebPluginDelegate* delegate,
-                                 bool load_manually);
+                                 bool load_manually,
+                                 const std::string& mime_type);
   virtual ~WebPluginImpl();
 
   virtual NPObject* GetPluginScriptableObject();
 
   // Helper function for sorting post data.
   static bool SetPostData(WebCore::ResourceRequest* request,
                           const char *buf,
                           uint32 length);
 
  private:
   friend class WebPluginContainer;
 
   WebPluginImpl(WebCore::Element *element, WebFrameImpl *frame,
                 WebPluginDelegate* delegate, const GURL& plugin_url,
-                bool load_manually);
+                bool load_manually, const std::string& mime_type,
+                int arg_count, char** arg_names, char** arg_values);
 
   // WebPlugin implementation:
   void SetWindow(HWND window, HANDLE pump_messages_event);
 
   // Given a (maybe partial) url, completes using the base url.
   bool CompleteURL(const std::string& url_in, std::string* url_out);
 
   // Executes the script passed in. The notify_needed and notify_data arguments
   // are passed in by the plugin process. These indicate whether the plugin
   // expects a notification on script execution. We pass them back to the
@@ skipping 71 matching lines @@
   virtual void hide();
 
   // Handle widget events.
   virtual void handleEvent(WebCore::Event* event);
   void handleMouseEvent(WebCore::MouseEvent* event);
   void handleKeyboardEvent(WebCore::KeyboardEvent* event);
 
   // Sets the actual Widget for the plugin.
   void SetContainer(WebPluginContainer* container);
 
+  // Destroys the plugin instance.
+  // The response_handle_to_ignore parameter if not NULL indicates the
+  // resource handle to be left valid during plugin shutdown.
+  void TearDownPluginInstance(
+      WebCore::ResourceHandle* response_handle_to_ignore);
+
   WebCore::ScrollView* parent() const;
 
   // ResourceHandleClient implementation.  We implement this interface in the
   // renderer process, and then use the simple WebPluginResourceClient interface
   // to relay the callbacks to the plugin.
   void willSendRequest(WebCore::ResourceHandle* handle,
                        WebCore::ResourceRequest& request,
                        const WebCore::ResourceResponse&);
 
   void didReceiveResponse(WebCore::ResourceHandle* handle,
@@ skipping 43 matching lines @@
   void HandleHttpMultipartResponse(const WebCore::ResourceResponse& response,
                                    WebPluginResourceClient* client);
 
   void HandleURLRequestInternal(const char *method, bool is_javascript_url,
                                 const char* target, unsigned int len,
                                 const char* buf, bool is_file_data,
                                 bool notify, const char* url,
                                 void* notify_data, bool popups_allowed,
                                 bool use_plugin_src_as_referrer);
 
+  // Tears down the existing plugin instance and creates a new plugin instance
+  // to handle the response identified by the response_handle parameter.
+  bool ReinitializePluginForResponse(WebCore::ResourceHandle* response_handle);
+
+  // Helper functions to convert an array of names/values to a vector.
+  static void ArrayToVector(int total_values, char** values, 
+                            std::vector<std::string>* value_vector);
+
   struct ClientInfo {
     int id;
     WebPluginResourceClient* client;
     WebCore::ResourceRequest request;
     RefPtr<WebCore::ResourceHandle> handle;
   };
 
   std::vector<ClientInfo> clients_;
 
   bool windowless_;
@@ skipping 18 matching lines @@
 
   // The plugin source URL.
   GURL plugin_url_;
 
   // Indicates if the download would be initiated by the plugin or us.
   bool load_manually_;
 
   // Indicates if this is the first geometry update received by the plugin.
   bool first_geometry_update_;
 
+  // The mime type of the plugin.
+  std::string mime_type_;
+
+  // Holds the list of argument names passed to the plugin.
+  std::vector<std::string> arg_names_;
+
+  // Holds the list of argument values passed to the plugin.
+  std::vector<std::string> arg_values_;
+
   DISALLOW_COPY_AND_ASSIGN(WebPluginImpl);
 };
 
 #endif  // #ifndef WEBKIT_GLUE_WEBPLUGIN_IMPL_H_