Lots of small nits to help to split off webkit.dll....

chrome/plugin/webplugin_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/plugin/webplugin_proxy.h"
 
 #include "base/gfx/gdi_util.h"
 #include "base/scoped_handle.h"
 #include "base/shared_memory.h"
 #include "base/singleton.h"
 #include "base/waitable_event.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/win_util.h"
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_util.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "chrome/plugin/plugin_thread.h"
 #include "chrome/plugin/webplugin_delegate_stub.h"
 #include "skia/ext/platform_device.h"
-#include "webkit/glue/plugins/webplugin_delegate_impl.h"
+#include "webkit/glue/webplugin_delegate.h"
 
 typedef std::map<CPBrowsingContext, WebPluginProxy*> ContextMap;
 static ContextMap& GetContextMap() {
   return *Singleton<ContextMap>::get();
 }
 
 WebPluginProxy::WebPluginProxy(
     PluginChannel* channel,
     int route_id,
-    WebPluginDelegateImpl* delegate,
+    WebPluginDelegate* delegate,
     HANDLE modal_dialog_event)
     : channel_(channel),
       route_id_(route_id),
       cp_browsing_context_(0),
       window_npobject_(NULL),
       plugin_element_(NULL),
       delegate_(delegate),
       waiting_for_paint_(false),
 #pragma warning(suppress: 4355)  // can use this
       runnable_method_factory_(this),
@@ skipping 60 matching lines @@
   Send(new PluginHostMsg_SetWindow(route_id_, window,
                                    pump_messages_event_for_renderer));
 }
 
 void WebPluginProxy::CancelResource(int id) {
   Send(new PluginHostMsg_CancelResource(route_id_, id));
   resource_clients_.erase(id);
 }
 
 void WebPluginProxy::Invalidate() {
-  gfx::Rect rect(0, 0, delegate_->rect().width(), delegate_->rect().height());
+  gfx::Rect rect(0, 0,
+                 delegate_->GetRect().width(),
+                 delegate_->GetRect().height());
   InvalidateRect(rect);
 }
 
 void WebPluginProxy::InvalidateRect(const gfx::Rect& rect) {
   damaged_rect_ = damaged_rect_.Union(rect);
   // Ignore NPN_InvalidateRect calls with empty rects.  Also don't send an
   // invalidate if it's outside the clipping region, since if we did it won't
   // lead to a paint and we'll be stuck waiting forever for a DidPaint response.
-  if (rect.IsEmpty() || !delegate_->clip_rect().Intersects(rect))
+  if (rect.IsEmpty() || !delegate_->GetClipRect().Intersects(rect))
     return;
 
   // Only send a single InvalidateRect message at a time.  From DidPaint we
   // will dispatch an additional InvalidateRect message if necessary.
   if (!waiting_for_paint_) {
     waiting_for_paint_ = true;
     // Invalidates caused by calls to NPN_InvalidateRect/NPN_InvalidateRgn
     // need to be painted asynchronously as per the NPAPI spec.
     MessageLoop::current()->PostTask(FROM_HERE,
         runnable_method_factory_.NewRunnableMethod(
@@ skipping 128 matching lines @@
                                       bool notify, const char* url,
                                       void* notify_data, bool popups_allowed) {
   if (!url) {
     NOTREACHED();
     return;
   }
 
   if (!target && (0 == _strcmpi(method, "GET"))) {
     // Please refer to https://bugzilla.mozilla.org/show_bug.cgi?id=366082
     // for more details on this.
-    if (delegate_->quirks() &
-        WebPluginDelegateImpl::PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS) {
+    if (delegate_->GetQuirks() &
+        WebPluginDelegate::PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS) {
       GURL request_url(url);
       if (!request_url.SchemeIs("http") && !request_url.SchemeIs("https") &&
           !request_url.SchemeIs("ftp")) {
         return;
       }
     }
   }
 
   PluginHostMsg_URLRequest_Params params;
   params.method = method;
@@ skipping 15 matching lines @@
   Send(new PluginHostMsg_URLRequest(route_id_, params));
 }
 
 void WebPluginProxy::Paint(const gfx::Rect& rect) {
   if (!windowless_hdc_)
     return;
 
   // Clear the damaged area so that if the plugin doesn't paint there we won't
   // end up with the old values.
   gfx::Rect offset_rect = rect;
-      offset_rect.Offset(delegate_->rect().x(), delegate_->rect().y());
+  offset_rect.Offset(delegate_->GetRect().origin());
   if (!background_hdc_) {
     FillRect(windowless_hdc_, &offset_rect.ToRECT(),
         static_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));
   } else {
     BitBlt(windowless_hdc_, offset_rect.x(), offset_rect.y(),
       offset_rect.width(), offset_rect.height(), background_hdc_,
       rect.x(), rect.y(), SRCCOPY);
   }
 
   // Before we send the invalidate, paint so that renderer uses the updated
   // bitmap.
   delegate_->Paint(windowless_hdc_, offset_rect);
 }
 
 void WebPluginProxy::UpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect,
     const base::SharedMemoryHandle& windowless_buffer,
     const base::SharedMemoryHandle& background_buffer) {
-  gfx::Rect old = delegate_->rect();
-  gfx::Rect old_clip_rect = delegate_->clip_rect();
+  gfx::Rect old = delegate_->GetRect();
+  gfx::Rect old_clip_rect = delegate_->GetClipRect();
 
-  bool moved = delegate_->rect().x() != window_rect.x() ||
-               delegate_->rect().y() != window_rect.y();
+  bool moved = old.x() != window_rect.x() || old.y() != window_rect.y();
   delegate_->UpdateGeometry(window_rect, clip_rect);
   if (windowless_buffer) {
     // The plugin's rect changed, so now we have a new buffer to draw into.
     SetWindowlessBuffer(windowless_buffer, background_buffer);
   } else if (moved) {
     // The plugin moved, so update our world transform.
     UpdateTransform();
   }
   // Send over any pending invalidates which occured when the plugin was
   // off screen.
-  if (delegate_->windowless() && !clip_rect.IsEmpty() &&
+  if (delegate_->IsWindowless() && !clip_rect.IsEmpty() &&
       old_clip_rect.IsEmpty() && !damaged_rect_.IsEmpty()) {
     InvalidateRect(damaged_rect_);
   }
 }
 
 void WebPluginProxy::SetWindowlessBuffer(
     const base::SharedMemoryHandle& windowless_buffer,
     const base::SharedMemoryHandle& background_buffer) {
   // Convert the shared memory handle to a handle that works in our process,
   // and then use that to create an HDC.
@@ skipping 17 matching lines @@
   shared_section->Set(win_util::GetSectionFromProcess(
       buffer, channel_->renderer_handle(), false));
   if (shared_section->Get() == NULL) {
     NOTREACHED();
     return;
   }
 
   void* data = NULL;
   HDC screen_dc = GetDC(NULL);
   BITMAPINFOHEADER bitmap_header;
-  gfx::CreateBitmapHeader(delegate_->rect().width(),
-                          delegate_->rect().height(),
+  gfx::CreateBitmapHeader(delegate_->GetRect().width(),
+                          delegate_->GetRect().height(),
                           &bitmap_header);
   bitmap->Set(CreateDIBSection(
       screen_dc, reinterpret_cast<const BITMAPINFO*>(&bitmap_header),
       DIB_RGB_COLORS, &data, shared_section->Get(), 0));
   ReleaseDC(NULL, screen_dc);
   if (bitmap->Get() == NULL) {
     NOTREACHED();
     return;
   }
 
   hdc->Set(CreateCompatibleDC(NULL));
   if (hdc->Get() == NULL) {
     NOTREACHED();
     return;
   }
 
   skia::PlatformDeviceWin::InitializeDC(hdc->Get());
   SelectObject(hdc->Get(), bitmap->Get());
 }
 
 void WebPluginProxy::UpdateTransform() {
   if (!windowless_hdc_)
     return;
 
   XFORM xf;
-  xf.eDx = static_cast<FLOAT>(-delegate_->rect().x());
-  xf.eDy = static_cast<FLOAT>(-delegate_->rect().y());
+  xf.eDx = static_cast<FLOAT>(-delegate_->GetRect().x());
+  xf.eDy = static_cast<FLOAT>(-delegate_->GetRect().y());
   xf.eM11 = 1;
   xf.eM21 = 0;
   xf.eM12 = 0;
   xf.eM22 = 1;
   SetWorldTransform(windowless_hdc_, &xf);
 }
 
 void WebPluginProxy::CancelDocumentLoad() {
   Send(new PluginHostMsg_CancelDocumentLoad(route_id_));
 }
 
 void WebPluginProxy::InitiateHTTPRangeRequest(const char* url,
                                               const char* range_info,
                                               void* existing_stream,
                                               bool notify_needed,
                                               HANDLE notify_data) {
 
   Send(new PluginHostMsg_InitiateHTTPRangeRequest(route_id_, url,
                                                   range_info, existing_stream,
                                                   notify_needed, notify_data));
 }
 
 void WebPluginProxy::OnPaint(const gfx::Rect& damaged_rect) {
   Paint(damaged_rect);
   Send(new PluginHostMsg_InvalidateRect(route_id_, damaged_rect));
 }