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

chrome/browser/renderer_host/render_widget_host_view_win.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/browser/renderer_host/render_widget_host_view_win.h"
 
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/resource_bundle.h"
@@ skipping 24 matching lines @@
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 #include "webkit/glue/webcursor.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 using WebKit::WebInputEvent;
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseEvent;
+using WebKit::WebTextDirection;
 
 namespace {
 
 // Tooltips will wrap after this width. Yes, wrap. Imagine that!
 const int kTooltipMaxWidthPixels = 300;
 
 // Maximum number of characters we allow in a tooltip.
 const int kMaxTooltipLength = 1024;
 
 // A callback function for EnumThreadWindows to enumerate and dismiss
@@ skipping 50 matching lines @@
   return false;
 }
 
 // Returns the text direction according to the keyboard status.
 // This function retrieves the status of all keys and returns the following
 // values:
 // * WEB_TEXT_DIRECTION_RTL
 //   If only a control key and a right-shift key are down.
 // * WEB_TEXT_DIRECTION_LTR
 //   If only a control key and a left-shift key are down.
+
 static bool GetNewTextDirection(WebTextDirection* direction) {
   uint8_t keystate[256];
   if (!GetKeyboardState(&keystate[0]))
     return false;
 
   // To check if a user is pressing only a control key and a right-shift key
   // (or a left-shift key), we use the steps below:
   // 1. Check if a user is pressing a control key and a right-shift key (or
   //    a left-shift key).
   // 2. If the condition 1 is true, we should check if there are any other
   //    keys pressed at the same time.
   //    To ignore the keys checked in 1, we set their status to 0 before
   //    checking the key status.
   const int kKeyDownMask = 0x80;
   if ((keystate[VK_CONTROL] & kKeyDownMask) == 0)
     return false;
 
   if (keystate[VK_RSHIFT] & kKeyDownMask) {
     keystate[VK_RSHIFT] = 0;
-    *direction = WEB_TEXT_DIRECTION_RTL;
+    *direction = WebKit::WebTextDirectionRightToLeft;
   } else if (keystate[VK_LSHIFT] & kKeyDownMask) {
     keystate[VK_LSHIFT] = 0;
-    *direction = WEB_TEXT_DIRECTION_LTR;
+    *direction = WebKit::WebTextDirectionLeftToRight;
   } else {
     return false;
   }
 
   // Scan the key status to find pressed keys. We should adandon changing the
   // text direction when there are other pressed keys.
   // This code is executed only when a user is pressing a control key and a
   // right-shift key (or a left-shift key), i.e. we should ignore the status of
   // the keys: VK_SHIFT, VK_CONTROL, VK_RCONTROL, and VK_LCONTROL.
   // So, we reset their status to 0 and ignore them.
@@ skipping 786 matching lines @@
 LRESULT RenderWidgetHostViewWin::OnImeComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   // At first, update the position of the IME window.
   ime_input_.UpdateImeWindow(m_hWnd);
 
   // Retrieve the result string and its attributes of the ongoing composition
   // and send it to a renderer process.
   ImeComposition composition;
   if (ime_input_.GetResult(m_hWnd, lparam, &composition)) {
     Send(new ViewMsg_ImeSetComposition(render_widget_host_->routing_id(),
-                                       1,
+                                       WebKit::WebCompositionCommandConfirm,
                                        composition.cursor_position,
                                        composition.target_start,
                                        composition.target_end,
                                        composition.ime_string));
     ime_input_.ResetComposition(m_hWnd);
     // Fall though and try reading the composition string.
     // Japanese IMEs send a message containing both GCS_RESULTSTR and
     // GCS_COMPSTR, which means an ongoing composition has been finished
     // by the start of another composition.
   }
   // Retrieve the composition string and its attributes of the ongoing
   // composition and send it to a renderer process.
   if (ime_input_.GetComposition(m_hWnd, lparam, &composition)) {
     Send(new ViewMsg_ImeSetComposition(render_widget_host_->routing_id(),
-                                       0,
+                                       WebKit::WebCompositionCommandSet,
                                        composition.cursor_position,
                                        composition.target_start,
                                        composition.target_end,
                                        composition.ime_string));
   }
   // We have to prevent WTL from calling ::DefWindowProc() because we do not
   // want for the IMM (Input Method Manager) to send WM_IME_CHAR messages.
   handled = TRUE;
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnImeEndComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   if (ime_input_.is_composing()) {
     // A composition has been ended while there is an ongoing composition,
     // i.e. the ongoing composition has been canceled.
     // We need to reset the composition status both of the ImeInput object and
     // of the renderer process.
     std::wstring empty_string;
     Send(new ViewMsg_ImeSetComposition(render_widget_host_->routing_id(),
-                                       -1, -1, -1, -1, empty_string));
+                                       WebKit::WebCompositionCommandDiscard,
+                                       -1, -1, -1, empty_string));
     ime_input_.ResetComposition(m_hWnd);
   }
   ime_input_.DestroyImeWindow(m_hWnd);
   // Let WTL call ::DefWindowProc() and release its resources.
   handled = FALSE;
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnMouseEvent(UINT message, WPARAM wparam,
                                               LPARAM lparam, BOOL& handled) {
@@ skipping 327 matching lines @@
     // WM_LBUTTONDOWN.
     SetFocus();
   }
 }
 
 void RenderWidgetHostViewWin::ShutdownHost() {
   shutdown_factory_.RevokeAll();
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }