Eliminate remaining WebCore dependencies from webplugin_impl.cc...

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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
@@ skipping 41 matching lines @@
 
 using WebKit::WebBindings;
 using WebKit::WebCursorInfo;
 using WebKit::WebInputEvent;
 using WebKit::WebDragData;
 using WebKit::WebVector;
 using WebKit::WebString;
 
 // Proxy for WebPluginResourceClient.  The object owns itself after creation,
 // deleting itself after its callback has been called.
-class ResourceClientProxy : public WebPluginResourceClient {
+class ResourceClientProxy : public webkit_glue::WebPluginResourceClient {
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
       notify_needed_(false), notify_data_(NULL),
       multibyte_response_expected_(false) {
   }
 
   ~ResourceClientProxy() {
   }
 
@@ skipping 82 matching lines @@
   intptr_t 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) {
+    const base::WeakPtr<RenderView>& render_view) {
   return new WebPluginDelegateProxy(mime_type, clsid, render_view);
 }
 
-WebPluginDelegateProxy::WebPluginDelegateProxy(const std::string& mime_type,
-                                               const std::string& clsid,
-                                               RenderView* render_view)
+WebPluginDelegateProxy::WebPluginDelegateProxy(
+    const std::string& mime_type,
+    const std::string& clsid,
+    const base::WeakPtr<RenderView>& render_view)
     : render_view_(render_view),
       plugin_(NULL),
       windowless_(false),
       window_(NULL),
       mime_type_(mime_type),
       clsid_(clsid),
       npobject_(NULL),
       window_script_object_(NULL),
       sad_plugin_(NULL),
       invalidate_pending_(false),
@@ skipping 32 matching lines @@
     // Release the channel host now. If we are is the last reference to the
     // channel, this avoids a race where this renderer asks a new connection to
     // the same plugin between now and the time 'this' is actually deleted.
     // Destroying the channel host is what releases the channel name -> FD
     // association on POSIX, and if we ask for a new connection before it is
     // released, the plugin will give us a new FD, and we'll assert when trying
     // to associate it with the channel name.
     channel_host_ = NULL;
   }
 
-  render_view_->PluginDestroyed(this);
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 bool WebPluginDelegateProxy::Initialize(const GURL& url, char** argn,
                                         char** argv, int argc,
-                                        WebPlugin* plugin,
+                                        webkit_glue::WebPlugin* plugin,
                                         bool load_manually) {
   IPC::ChannelHandle channel_handle;
   FilePath plugin_path;
   if (!RenderThread::current()->Send(new ViewHostMsg_OpenChannelToPlugin(
           url, mime_type_, clsid_, webkit_glue::GetWebKitLocale(),
           &channel_handle, &plugin_path))) {
     return false;
   }
 
 #if defined(OS_POSIX)
@@ skipping 633 matching lines @@
                                           std::string* cookies) {
   DCHECK(cookies);
   if (plugin_)
     *cookies = plugin_->GetCookies(url, first_party_for_cookies);
 }
 
 void WebPluginDelegateProxy::OnShowModalHTMLDialog(
     const GURL& url, int width, int height, const std::string& json_arguments,
     std::string* json_retval) {
   DCHECK(json_retval);
-  if (render_view_)
-    render_view_->ShowModalHTMLDialog(url, width, height, json_arguments,
-                                      json_retval);
+  if (render_view_) {
+    render_view_->ShowModalHTMLDialogForPlugin(
+        url, gfx::Size(width, height), json_arguments, json_retval);
+  }
 }
 
 static void EncodeDragData(const WebDragData& data, bool add_data,
                            NPVariant* drag_type, NPVariant* drag_data) {
   const NPString* np_drag_type;
   if (data.hasFileNames()) {
     static const NPString kFiles = { "Files", 5 };
     np_drag_type = &kFiles;
   } else {
     static const NPString kEmpty = { "" , 0 };
@@ skipping 144 matching lines @@
     target = params.target.c_str();
 
   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(
+webkit_glue::WebPluginResourceClient*
+WebPluginDelegateProxy::CreateResourceClient(
     int resource_id, const GURL& url, bool notify_needed,
     intptr_t notify_data, intptr_t npstream) {
   ResourceClientProxy* proxy = new ResourceClientProxy(channel_host_,
                                                        instance_id_);
   proxy->Initialize(resource_id, url, notify_needed, notify_data, npstream);
   return proxy;
 }
 
+bool WebPluginDelegateProxy::IsWindowless() const {
+  NOTREACHED();
+  return false;
+}
+
+gfx::Rect WebPluginDelegateProxy::GetRect() const {
+  NOTREACHED();
+  return gfx::Rect();
+}
+
+gfx::Rect WebPluginDelegateProxy::GetClipRect() const {
+  NOTREACHED();
+  return gfx::Rect();
+}
+
+int WebPluginDelegateProxy::GetQuirks() const {
+  NOTREACHED();
+  return 0;
+}
+
 void WebPluginDelegateProxy::OnCancelDocumentLoad() {
   plugin_->CancelDocumentLoad();
 }
 
 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
     const std::string& url, const std::string& range_info,
     intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }
 
 void WebPluginDelegateProxy::OnDeferResourceLoading(int resource_id,
                                                     bool defer) {
   plugin_->SetDeferResourceLoading(resource_id, defer);
 }