Use WebWidget from the WebKit API. This change also makes...

chrome/renderer/render_widget.cc

 // Copyright (c) 2009 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/render_widget.h"
 
 #include "base/gfx/point.h"
 #include "base/gfx/size.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/transport_dib.h"
 #include "chrome/renderer/render_process.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "webkit/api/public/WebCursorInfo.h"
+#include "webkit/api/public/WebPopupMenu.h"
 #include "webkit/api/public/WebPopupMenuInfo.h"
 #include "webkit/api/public/WebRect.h"
 #include "webkit/api/public/WebScreenInfo.h"
 #include "webkit/api/public/WebSize.h"
 
 #if defined(OS_POSIX)
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #endif  // defined(OS_POSIX)
 
-#include "webkit/glue/webtextdirection.h"
-#include "webkit/glue/webwidget.h"
+#include "webkit/api/public/WebWidget.h"
 
+using WebKit::WebCompositionCommand;
 using WebKit::WebCursorInfo;
 using WebKit::WebInputEvent;
+using WebKit::WebNavigationPolicy;
+using WebKit::WebPopupMenu;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebRect;
 using WebKit::WebScreenInfo;
 using WebKit::WebSize;
+using WebKit::WebTextDirection;
 
 RenderWidget::RenderWidget(RenderThreadBase* render_thread, bool activatable)
     : routing_id_(MSG_ROUTING_NONE),
       webwidget_(NULL),
       opener_id_(MSG_ROUTING_NONE),
       render_thread_(render_thread),
       host_window_(NULL),
       current_paint_buf_(NULL),
       current_scroll_buf_(NULL),
       next_paint_flags_(0),
@@ skipping 47 matching lines @@
   for (size_t i = 0; i < info.items.size(); ++i)
     popup_params_->popup_items.push_back(WebMenuItem(info.items[i]));
 }
 
 void RenderWidget::Init(int32 opener_id) {
   DCHECK(!webwidget_);
 
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
-  webwidget_ = WebWidget::Create(this);
+  webwidget_ = WebPopupMenu::create(this);
 
   bool result = render_thread_->Send(
       new ViewHostMsg_CreateWidget(opener_id, activatable_, &routing_id_));
   if (result) {
     render_thread_->AddRoute(routing_id_, this);
     // Take a reference on behalf of the RenderThread.  This will be balanced
     // when we receive ViewMsg_Close.
     AddRef();
   } else {
     DCHECK(false);
@@ skipping 87 matching lines @@
   // We shouldn't be asked to resize to our current size.
   DCHECK(size_ != new_size);
   size_ = new_size;
 
   // We should not be sent a Resize message if we have not ACK'd the previous
   DCHECK(!next_paint_is_resize_ack());
 
   // When resizing, we want to wait to paint before ACK'ing the resize.  This
   // ensures that we only resize as fast as we can paint.  We only need to send
   // an ACK if we are resized to a non-empty rect.
-  webwidget_->Resize(new_size);
+  webwidget_->resize(new_size);
   if (!new_size.IsEmpty()) {
     DCHECK(!paint_rect_.IsEmpty());
 
     // This should have caused an invalidation of the entire view.  The damaged
     // rect could be larger than new_size if we are being made smaller.
     DCHECK_GE(paint_rect_.width(), new_size.width());
     DCHECK_GE(paint_rect_.height(), new_size.height());
 
     // We will send the Resize_ACK flag once we paint again.
     set_next_paint_is_resize_ack();
@@ skipping 15 matching lines @@
 
   if (!needs_repainting && !needs_repainting_on_restore_)
     return;
   needs_repainting_on_restore_ = false;
 
   // Tag the next paint as a restore ack, which is picked up by DoDeferredPaint
   // when it sends out the next PaintRect message.
   set_next_paint_is_restore_ack();
 
   // Generate a full repaint.
-  DidInvalidateRect(webwidget_, gfx::Rect(size_.width(), size_.height()));
+  didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
 }
 
 void RenderWidget::OnPaintRectAck() {
   DCHECK(paint_reply_pending());
   paint_reply_pending_ = false;
   // If we sent a PaintRect message with a zero-sized bitmap, then
   // we should have no current paint buf.
   if (current_paint_buf_) {
     RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
     current_paint_buf_ = NULL;
@@ skipping 28 matching lines @@
 
   const char* data;
   int data_length;
   if (!message.ReadData(&iter, &data, &data_length))
     return;
 
   const WebInputEvent* input_event =
       reinterpret_cast<const WebInputEvent*>(data);
   bool processed = false;
   if (webwidget_)
-    processed = webwidget_->HandleInputEvent(input_event);
+    processed = webwidget_->handleInputEvent(*input_event);
 
   IPC::Message* response = new ViewHostMsg_HandleInputEvent_ACK(routing_id_);
   response->WriteInt(input_event->type);
   response->WriteBool(processed);
 
   Send(response);
 }
 
 void RenderWidget::OnMouseCaptureLost() {
   if (webwidget_)
-    webwidget_->MouseCaptureLost();
+    webwidget_->mouseCaptureLost();
 }
 
 void RenderWidget::OnSetFocus(bool enable) {
   has_focus_ = enable;
   if (webwidget_)
-    webwidget_->SetFocus(enable);
+    webwidget_->setFocus(enable);
   if (enable) {
     // Force to retrieve the state of the focused widget to determine if we
     // should activate IMEs next time when this process calls the UpdateIME()
     // function.
     ime_control_updated_ = true;
     ime_control_new_state_ = true;
   }
 }
 
 void RenderWidget::ClearFocus() {
   // We may have got the focus from the browser before this gets processed, in
   // which case we do not want to unfocus ourself.
   if (!has_focus_ && webwidget_)
-    webwidget_->SetFocus(false);
+    webwidget_->setFocus(false);
 }
 
 void RenderWidget::PaintRect(const gfx::Rect& rect,
                              skia::PlatformCanvas* canvas) {
 
   // Bring the canvas into the coordinate system of the paint rect.
   canvas->translate(static_cast<SkScalar>(-rect.x()),
                     static_cast<SkScalar>(-rect.y()));
 
   // If there is a custom background, tile it.
   if (!background_.empty()) {
     SkPaint paint;
     SkShader* shader = SkShader::CreateBitmapShader(background_,
                                                     SkShader::kRepeat_TileMode,
                                                     SkShader::kRepeat_TileMode);
     paint.setShader(shader)->unref();
     paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
     canvas->drawPaint(paint);
   }
 
-  webwidget_->Paint(canvas, rect);
+  webwidget_->paint(canvas, rect);
 
   // Flush to underlying bitmap.  TODO(darin): is this needed?
   canvas->getTopPlatformDevice().accessBitmap(false);
 }
 
 void RenderWidget::DoDeferredPaint() {
   if (!webwidget_ || paint_reply_pending() || paint_rect_.IsEmpty())
     return;
 
   // When we are hidden, we want to suppress painting, but we still need to
   // mark this DoDeferredPaint as complete.
   if (is_hidden_ || size_.IsEmpty()) {
     paint_rect_ = gfx::Rect();
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // Layout may generate more invalidation...
-  webwidget_->Layout();
+  webwidget_->layout();
 
   // OK, save the current paint_rect to a local since painting may cause more
   // invalidation.  Some WebCore rendering objects only layout when painted.
   gfx::Rect damaged_rect = paint_rect_;
   paint_rect_ = gfx::Rect();
 
   // Compute a buffer for painting and cache it.
   skia::PlatformCanvas* canvas =
       RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
                                                  damaged_rect);
@@ skipping 33 matching lines @@
   // When we are hidden, we want to suppress scrolling, but we still need to
   // mark this DoDeferredScroll as complete.
   if (is_hidden_ || size_.IsEmpty()) {
     scroll_rect_ = gfx::Rect();
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // Layout may generate more invalidation, so we might have to bail on
   // optimized scrolling...
-  webwidget_->Layout();
+  webwidget_->layout();
 
   if (scroll_rect_.IsEmpty())
     return;
 
   gfx::Rect damaged_rect;
 
   // Compute the region we will expose by scrolling, and paint that into a
   // shared memory section.
   if (scroll_delta_.x()) {
     int dx = scroll_delta_.x();
@@ skipping 52 matching lines @@
 
   PaintRect(damaged_rect, canvas);
   Send(new ViewHostMsg_ScrollRect(routing_id_, params));
   delete canvas;
   UpdateIME();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebWidgetDelegate
 
-void RenderWidget::DidInvalidateRect(WebWidget* webwidget,
-                                     const WebRect& rect) {
+void RenderWidget::didInvalidateRect(const WebRect& rect) {
   // We only want one pending DoDeferredPaint call at any time...
   bool paint_pending = !paint_rect_.IsEmpty();
 
   // If this invalidate overlaps with a pending scroll, then we have to
   // downgrade to invalidating the scroll rect.
   if (gfx::Rect(rect).Intersects(scroll_rect_)) {
     paint_rect_ = paint_rect_.Union(scroll_rect_);
     scroll_rect_ = gfx::Rect();
   }
 
@@ skipping 10 matching lines @@
 
   // Perform painting asynchronously.  This serves two purposes:
   // 1) Ensures that we call WebView::Paint without a bunch of other junk
   //    on the call stack.
   // 2) Allows us to collect more damage rects before painting to help coalesce
   //    the work that we will need to do.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &RenderWidget::DoDeferredPaint));
 }
 
-void RenderWidget::DidScrollRect(WebWidget* webwidget, int dx, int dy,
-                                 const WebRect& clip_rect) {
+void RenderWidget::didScrollRect(int dx, int dy, const WebRect& clip_rect) {
   if (dx != 0 && dy != 0) {
     // We only support scrolling along one axis at a time.
-    DidScrollRect(webwidget, 0, dy, clip_rect);
+    didScrollRect(0, dy, clip_rect);
     dy = 0;
   }
 
   bool intersects_with_painting = paint_rect_.Intersects(clip_rect);
 
   // If we already have a pending scroll operation or if this scroll operation
   // intersects the existing paint region, then just failover to invalidating.
   if (!scroll_rect_.IsEmpty() || intersects_with_painting) {
     if (!intersects_with_painting && scroll_rect_ == gfx::Rect(clip_rect)) {
       // OK, we can just update the scroll delta (requires same scrolling axis)
       if (!dx && !scroll_delta_.x()) {
         scroll_delta_.set_y(scroll_delta_.y() + dy);
         return;
       }
       if (!dy && !scroll_delta_.y()) {
         scroll_delta_.set_x(scroll_delta_.x() + dx);
         return;
       }
     }
-    DidInvalidateRect(webwidget_, scroll_rect_);
+    didInvalidateRect(scroll_rect_);
     DCHECK(scroll_rect_.IsEmpty());
-    DidInvalidateRect(webwidget_, clip_rect);
+    didInvalidateRect(clip_rect);
     return;
   }
 
   // We only want one pending DoDeferredScroll call at any time...
   bool scroll_pending = !scroll_rect_.IsEmpty();
 
   scroll_rect_ = clip_rect;
   scroll_delta_.SetPoint(dx, dy);
 
   if (scroll_pending)
     return;
 
   // Perform scrolling asynchronously since we need to call WebView::Paint
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &RenderWidget::DoDeferredScroll));
 }
 
-void RenderWidget::SetCursor(WebWidget* webwidget,
-                             const WebCursorInfo& cursor_info) {
+void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
   // TODO(darin): Eliminate this temporary.
   WebCursor cursor(cursor_info);
 
   // Only send a SetCursor message if we need to make a change.
   if (!current_cursor_.IsEqual(cursor)) {
     current_cursor_ = cursor;
     Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
   }
 }
 
 // We are supposed to get a single call to Show for a newly created RenderWidget
 // that was created via RenderWidget::CreateWebView.  So, we wait until this
 // point to dispatch the ShowWidget message.
 //
 // This method provides us with the information about how to display the newly
 // created RenderWidget (i.e., as a constrained popup or as a new tab).
 //
-void RenderWidget::Show(WebWidget* webwidget,
-                        WindowOpenDisposition disposition) {
+void RenderWidget::show(WebNavigationPolicy) {
   DCHECK(!did_show_) << "received extraneous Show call";
   DCHECK(routing_id_ != MSG_ROUTING_NONE);
   DCHECK(opener_id_ != MSG_ROUTING_NONE);
 
   if (!did_show_) {
     did_show_ = true;
     // NOTE: initial_pos_ may still have its default values at this point, but
     // that's okay.  It'll be ignored if as_popup is false, or the browser
     // process will impose a default position otherwise.
     if (popup_params_.get()) {
       popup_params_->bounds = initial_pos_;
       Send(new ViewHostMsg_ShowPopup(routing_id_, *popup_params_));
       popup_params_.reset();
     } else {
       Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
     }
     SetPendingWindowRect(initial_pos_);
   }
 }
 
-void RenderWidget::Focus(WebWidget* webwidget) {
+void RenderWidget::didFocus() {
   // Prevent the widget from stealing the focus if it does not have focus
   // already.  We do this by explicitely setting the focus to false again.
   // We only let the browser focus the renderer.
   if (!has_focus_ && webwidget_) {
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &RenderWidget::ClearFocus));
   }
 }
 
-void RenderWidget::Blur(WebWidget* webwidget) {
+void RenderWidget::didBlur() {
   Send(new ViewHostMsg_Blur(routing_id_));
 }
 
 void RenderWidget::DoDeferredClose() {
   Send(new ViewHostMsg_Close(routing_id_));
 }
 
-void RenderWidget::CloseWidgetSoon(WebWidget* webwidget) {
+void RenderWidget::closeWidgetSoon() {
   // If a page calls window.close() twice, we'll end up here twice, but that's
   // OK.  It is safe to send multiple Close messages.
 
   // Ask the RenderWidgetHost to initiate close.  We could be called from deep
   // in Javascript.  If we ask the RendwerWidgetHost to close now, the window
   // could be closed before the JS finishes executing.  So instead, post a
   // message back to the message loop, which won't run until the JS is
   // complete, and then the Close message can be sent.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &RenderWidget::DoDeferredClose));
 }
 
 void RenderWidget::GenerateFullRepaint() {
-  DidInvalidateRect(webwidget_, gfx::Rect(size_.width(), size_.height()));
+  didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
 }
 
 void RenderWidget::Close() {
   if (webwidget_) {
-    webwidget_->Close();
+    webwidget_->close();
     webwidget_ = NULL;
   }
 }
 
-void RenderWidget::GetWindowRect(WebWidget* webwidget, WebRect* result) {
-  if (pending_window_rect_count_) {
-    *result = pending_window_rect_;
-    return;
-  }
+WebRect RenderWidget::windowRect() {
+  if (pending_window_rect_count_)
+    return pending_window_rect_;
 
   gfx::Rect rect;
   Send(new ViewHostMsg_GetWindowRect(routing_id_, host_window_, &rect));
-  *result = rect;
+  return rect;
 }
 
-void RenderWidget::SetWindowRect(WebWidget* webwidget, const WebRect& pos) {
+void RenderWidget::setWindowRect(const WebRect& pos) {
   if (did_show_) {
     Send(new ViewHostMsg_RequestMove(routing_id_, pos));
     SetPendingWindowRect(pos);
   } else {
     initial_pos_ = pos;
   }
 }
 
 void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
   pending_window_rect_ = rect;
   pending_window_rect_count_++;
 }
 
-void RenderWidget::GetRootWindowRect(WebWidget* webwidget, WebRect* result) {
+WebRect RenderWidget::rootWindowRect() {
   if (pending_window_rect_count_) {
     // NOTE(mbelshe): If there is a pending_window_rect_, then getting
     // the RootWindowRect is probably going to return wrong results since the
     // browser may not have processed the Move yet.  There isn't really anything
     // good to do in this case, and it shouldn't happen - since this size is
     // only really needed for windowToScreen, which is only used for Popups.
-    *result = pending_window_rect_;
-    return;
+    return pending_window_rect_;
   }
 
   gfx::Rect rect;
   Send(new ViewHostMsg_GetRootWindowRect(routing_id_, host_window_, &rect));
-  *result = rect;
+  return rect;
 }
 
-void RenderWidget::GetRootWindowResizerRect(WebWidget* webwidget,
-                                            WebRect* rect) {
-  *rect = resizer_rect_;
+WebRect RenderWidget::windowResizerRect() {
+  return resizer_rect_;
 }
 
 void RenderWidget::OnImeSetInputMode(bool is_active) {
   // To prevent this renderer process from sending unnecessary IPC messages to
   // a browser process, we permit the renderer process to send IPC messages
   // only during the IME attached to the browser process is active.
   ime_is_active_ = is_active;
 }
 
-void RenderWidget::OnImeSetComposition(int string_type,
+void RenderWidget::OnImeSetComposition(WebCompositionCommand command,
                                        int cursor_position,
                                        int target_start, int target_end,
-                                       const std::wstring& ime_string) {
-  if (webwidget_) {
-    ime_control_busy_ = true;
-    webwidget_->ImeSetComposition(string_type, cursor_position,
-                                  target_start, target_end,
-                                  ime_string);
-    ime_control_busy_ = false;
-  }
+                                       const string16& ime_string) {
+  if (!webwidget_)
+    return;
+  ime_control_busy_ = true;
+  webwidget_->handleCompositionEvent(command, cursor_position,
+                                     target_start, target_end,
+                                     ime_string);
+  ime_control_busy_ = false;
 }
 
 void RenderWidget::OnMsgRepaint(const gfx::Size& size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   set_next_paint_is_repaint_ack();
   gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
-  DidInvalidateRect(webwidget_, repaint_rect);
+  didInvalidateRect(repaint_rect);
 }
 
-void RenderWidget::OnSetTextDirection(int direction) {
+void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
   if (!webwidget_)
     return;
-
-  WebTextDirection new_direction = static_cast<WebTextDirection>(direction);
-  if (new_direction == WEB_TEXT_DIRECTION_DEFAULT ||
-      new_direction == WEB_TEXT_DIRECTION_LTR ||
-      new_direction == WEB_TEXT_DIRECTION_RTL) {
-    webwidget_->SetTextDirection(new_direction);
-  } else {
-    NOTREACHED();
-  }
+  webwidget_->setTextDirection(direction);
 }
 
 void RenderWidget::SetBackground(const SkBitmap& background) {
   background_ = background;
   // Generate a full repaint.
-  DidInvalidateRect(webwidget_, gfx::Rect(size_.width(), size_.height()));
+  didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
 }
 
 bool RenderWidget::next_paint_is_resize_ack() const {
   return ViewHostMsg_PaintRect_Flags::is_resize_ack(next_paint_flags_);
 }
 
 bool RenderWidget::next_paint_is_restore_ack() const {
   return ViewHostMsg_PaintRect_Flags::is_restore_ack(next_paint_flags_);
 }
 
@@ skipping 15 matching lines @@
   // a renderer process does not have to retrieve information of the focused
   // control or send notification messages to a browser process.
   if (!ime_is_active_) {
     return;
   }
   // Retrieve the caret position from the focused widget and verify we should
   // enabled IMEs attached to the browser process.
   bool enable_ime = false;
   WebRect caret_rect;
   if (!webwidget_ ||
-      !webwidget_->ImeUpdateStatus(&enable_ime, &caret_rect)) {
+      !webwidget_->queryCompositionStatus(&enable_ime, &caret_rect)) {
     // There are not any editable widgets attached to this process.
     // We should disable the IME to prevent it from sending CJK strings to
     // non-editable widgets.
     ime_control_updated_ = true;
     ime_control_new_state_ = false;
   }
   if (ime_control_new_state_ != enable_ime) {
     ime_control_updated_ = true;
     ime_control_new_state_ = enable_ime;
   }
@@ skipping 37 matching lines @@
       }
     }
   }
   // Save the updated IME status to prevent from sending the same IPC messages.
   ime_control_updated_ = false;
   ime_control_enable_ime_ = ime_control_new_state_;
   ime_control_x_ = caret_rect.x;
   ime_control_y_ = caret_rect.y;
 }
 
-void RenderWidget::DidMove(WebWidget* webwidget,
-                           const WebPluginGeometry& move) {
+WebScreenInfo RenderWidget::screenInfo() {
+  WebScreenInfo results;
+  Send(new ViewHostMsg_GetScreenInfo(routing_id_, host_window_, &results));
+  return results;
+}
+
+void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
   size_t i = 0;
   for (; i < plugin_window_moves_.size(); ++i) {
     if (plugin_window_moves_[i].window == move.window) {
       plugin_window_moves_[i] = move;
       break;
     }
   }
 
   if (i == plugin_window_moves_.size())
     plugin_window_moves_.push_back(move);
 }
-
-WebScreenInfo RenderWidget::GetScreenInfo(WebWidget* webwidget) {
-  WebScreenInfo results;
-  Send(new ViewHostMsg_GetScreenInfo(routing_id_, host_window_, &results));
-  return results;
-}