Change imm32_manager_ using scoped_ptr for mock testing.

content/browser/renderer_host/render_widget_host_view_win.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <InputScope.h>
 #include <wtsapi32.h>
 #pragma comment(lib, "wtsapi32.lib")
 
@@ skipping 373 matching lines @@
 typedef void (*MetroCloseFrameWindow)(HWND window);
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewWin, public:
 
 RenderWidgetHostViewWin::RenderWidgetHostViewWin(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       compositor_host_window_(NULL),
       hide_compositor_window_at_next_paint_(false),
       track_mouse_leave_(false),
+      imm32_manager_(new ui::IMM32Manager),
       ime_notification_(false),
       capture_enter_key_(false),
       is_hidden_(false),
       about_to_validate_and_paint_(false),
       close_on_deactivate_(false),
       being_destroyed_(false),
       tooltip_hwnd_(NULL),
       tooltip_showing_(false),
       weak_factory_(this),
       is_loading_(false),
@@ skipping 296 matching lines @@
   }
 }
 
 void RenderWidgetHostViewWin::SelectionBoundsChanged(
     const ViewHostMsg_SelectionBounds_Params& params) {
   bool is_enabled = (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE &&
       text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD);
   // Only update caret position if the input method is enabled.
   if (is_enabled) {
     caret_rect_ = gfx::UnionRects(params.anchor_rect, params.focus_rect);
-    imm32_manager_.UpdateCaretRect(m_hWnd, caret_rect_);
+    imm32_manager_->UpdateCaretRect(m_hWnd, caret_rect_);
   }
 }
 
 void RenderWidgetHostViewWin::ScrollOffsetChanged() {
 }
 
 void RenderWidgetHostViewWin::ImeCancelComposition() {
-  imm32_manager_.CancelIME(m_hWnd);
+  imm32_manager_->CancelIME(m_hWnd);
 }
 
 void RenderWidgetHostViewWin::ImeCompositionRangeChanged(
     const ui::Range& range,
     const std::vector<gfx::Rect>& character_bounds) {
   composition_range_ = range;
   composition_character_bounds_ = character_bounds;
 }
 
 void RenderWidgetHostViewWin::Redraw() {
@@ skipping 799 matching lines @@
   //   (i.e. ime_notification_ == true),
   //   send this request only if the input context does not have IMEs,
   //   (i.e. ime_status == false).
   //   When it successfully sends the request, toggle its notification status,
   //   (i.e.ime_notification_ = !ime_notification_ = false).
   // To analyze the above actions, we can optimize them into the ones
   // listed below:
   // 1 Sending a request only if ime_status_ != ime_notification_, and;
   // 2 Copying ime_status to ime_notification_ if it sends the request
   //   successfully (because Action 1 shows ime_status = !ime_notification_.)
-  bool ime_status = imm32_manager_.SetInputLanguage();
+  bool ime_status = imm32_manager_->SetInputLanguage();
   if (ime_status != ime_notification_) {
     if (render_widget_host_) {
       render_widget_host_->SetInputMethodActive(ime_status);
       ime_notification_ = ime_status;
     }
   }
   // Call DefWindowProc() for consistency with other Chrome windows.
   // TODO(hbono): This is a speculative fix for Bug 36354 and this code may be
   // reverted if it does not fix it.
   SetMsgHandled(FALSE);
@@ skipping 51 matching lines @@
   // fortunately sent to an application only while the input context has IMEs.
   // Therefore, we just start/stop status messages according to the activation
   // status of this application without checks.
   bool activated = (wparam == TRUE);
   if (render_widget_host_) {
     render_widget_host_->SetInputMethodActive(activated);
     ime_notification_ = activated;
   }
 
   if (ime_notification_)
-    imm32_manager_.CreateImeWindow(m_hWnd);
+    imm32_manager_->CreateImeWindow(m_hWnd);
 
-  imm32_manager_.CleanupComposition(m_hWnd);
-  return imm32_manager_.SetImeWindowStyle(
+  imm32_manager_->CleanupComposition(m_hWnd);
+  return imm32_manager_->SetImeWindowStyle(
       m_hWnd, message, wparam, lparam, &handled);
 }
 
 LRESULT RenderWidgetHostViewWin::OnImeStartComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeStartComposition");
   if (!render_widget_host_)
     return 0;
 
   // Reset the composition status and create IME windows.
-  imm32_manager_.CreateImeWindow(m_hWnd);
-  imm32_manager_.ResetComposition(m_hWnd);
+  imm32_manager_->CreateImeWindow(m_hWnd);
+  imm32_manager_->ResetComposition(m_hWnd);
   // When the focus is on an element that does not draw composition by itself
   // (i.e., PPAPI plugin not handling IME), let IME to draw the text. Otherwise
   // we have to prevent WTL from calling ::DefWindowProc() because the function
   // calls ::ImmSetCompositionWindow() and ::ImmSetCandidateWindow() to
   // over-write the position of IME windows.
   handled = (can_compose_inline_ ? TRUE : FALSE);
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnImeComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeComposition");
   if (!render_widget_host_)
     return 0;
 
   // At first, update the position of the IME window.
-  imm32_manager_.UpdateImeWindow(m_hWnd);
+  imm32_manager_->UpdateImeWindow(m_hWnd);
 
   // ui::CompositionUnderline should be identical to
   // WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
   COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
                  sizeof(WebKit::WebCompositionUnderline),
                  ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
 
   // Retrieve the result string and its attributes of the ongoing composition
   // and send it to a renderer process.
   ui::CompositionText composition;
-  if (imm32_manager_.GetResult(m_hWnd, lparam, &composition.text)) {
+  if (imm32_manager_->GetResult(m_hWnd, lparam, &composition.text)) {
     render_widget_host_->ImeConfirmComposition(
         composition.text, ui::Range::InvalidRange(), false);
-    imm32_manager_.ResetComposition(m_hWnd);
+    imm32_manager_->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 (imm32_manager_.GetComposition(m_hWnd, lparam, &composition)) {
+  if (imm32_manager_->GetComposition(m_hWnd, lparam, &composition)) {
     // TODO(suzhe): due to a bug of webkit, we can't use selection range with
     // composition string. See: https://bugs.webkit.org/show_bug.cgi?id=37788
     composition.selection = ui::Range(composition.selection.end());
 
     // TODO(suzhe): convert both renderer_host and renderer to use
     // ui::CompositionText.
     const std::vector<WebKit::WebCompositionUnderline>& underlines =
         reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
             composition.underlines);
     render_widget_host_->ImeSetComposition(
@@ skipping 13 matching lines @@
   }
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnImeEndComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeEndComposition");
   if (!render_widget_host_)
     return 0;
 
-  if (imm32_manager_.is_composing()) {
+  if (imm32_manager_->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 IMM32Manager object
     // and of the renderer process.
     render_widget_host_->ImeCancelComposition();
-    imm32_manager_.ResetComposition(m_hWnd);
+    imm32_manager_->ResetComposition(m_hWnd);
   }
-  imm32_manager_.DestroyImeWindow(m_hWnd);
+  imm32_manager_->DestroyImeWindow(m_hWnd);
   // Let WTL call ::DefWindowProc() and release its resources.
   handled = FALSE;
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnImeRequest(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeRequest");
   if (!render_widget_host_) {
     handled = FALSE;
@@ skipping 98 matching lines @@
   if (!is_fullscreen_ && !close_on_deactivate_) {
     switch (message) {
       case WM_LBUTTONDOWN:
       case WM_MBUTTONDOWN:
       case WM_RBUTTONDOWN:
         // Finish the ongoing composition whenever a mouse click happens.
         // It matches IE's behavior.
         if (base::win::IsTSFAwareRequired()) {
           ui::TSFBridge::GetInstance()->CancelComposition();
         } else {
-          imm32_manager_.CleanupComposition(m_hWnd);
+          imm32_manager_->CleanupComposition(m_hWnd);
         }
         // Fall through.
       case WM_MOUSEMOVE:
       case WM_MOUSELEAVE: {
         // Give the WebContentsImpl first crack at the message. It may want to
         // prevent forwarding to the renderer if some higher level browser
         // functionality is invoked.
         LPARAM parent_msg_lparam = lparam;
         if (message != WM_MOUSELEAVE) {
           // For the messages except WM_MOUSELEAVE, before forwarding them to
@@ skipping 366 matching lines @@
 }
 
 LRESULT RenderWidgetHostViewWin::OnTouchEvent(UINT message, WPARAM wparam,
                                               LPARAM lparam, BOOL& handled) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnTouchEvent");
   // Finish the ongoing composition whenever a touch event happens.
   // It matches IE's behavior.
   if (base::win::IsTSFAwareRequired()) {
     ui::TSFBridge::GetInstance()->CancelComposition();
   } else {
-    imm32_manager_.CleanupComposition(m_hWnd);
+    imm32_manager_->CleanupComposition(m_hWnd);
   }
 
   // TODO(jschuh): Add support for an arbitrary number of touchpoints.
   size_t total = std::min(static_cast<int>(LOWORD(wparam)),
       static_cast<int>(WebKit::WebTouchEvent::touchesLengthCap));
   TOUCHINPUT points[WebKit::WebTouchEvent::touchesLengthCap];
 
   if (!total || !ui::GetTouchInputInfoWrapper((HTOUCHINPUT)lparam, total,
                                               points, sizeof(TOUCHINPUT))) {
     TRACE_EVENT0("browser", "EarlyOut_NothingToDo");
@@ skipping 836 matching lines @@
          selection_text_.c_str(), len * sizeof(WCHAR));
 
   // According to Microsft API document, IMR_RECONVERTSTRING and
   // IMR_DOCUMENTFEED should return reconv, but some applications return
   // need_size.
   return reinterpret_cast<LRESULT>(reconv);
 }
 
 LRESULT RenderWidgetHostViewWin::OnReconvertString(RECONVERTSTRING* reconv) {
   // If there is a composition string already, we don't allow reconversion.
-  if (imm32_manager_.is_composing())
+  if (imm32_manager_->is_composing())
     return 0;
 
   if (selection_range_.is_empty())
     return 0;
 
   if (selection_text_.empty())
     return 0;
 
   if (selection_range_.GetMin() < selection_text_offset_ ||
       selection_range_.GetMax() >
@@ skipping 29 matching lines @@
 }
 
 LRESULT RenderWidgetHostViewWin::OnQueryCharPosition(
     IMECHARPOSITION* position) {
   DCHECK(position);
 
   if (position->dwSize < sizeof(IMECHARPOSITION))
     return 0;
 
   RECT target_rect = {};
-  if (imm32_manager_.is_composing() && !composition_range_.is_empty() &&
+  if (imm32_manager_->is_composing() && !composition_range_.is_empty() &&
       position->dwCharPos < composition_character_bounds_.size()) {
     target_rect =
         composition_character_bounds_[position->dwCharPos].ToRECT();
   } else if (position->dwCharPos == 0) {
     // When there is no on-going composition but |position->dwCharPos| is 0,
     // use the caret rect. This behavior is the same to RichEdit. In fact,
     // CUAS (Cicero Unaware Application Support) relies on this behavior to
     // implement ITfContextView::GetTextExt on top of IMM32-based applications.
     target_rect = caret_rect_.ToRECT();
   } else {
@@ skipping 11 matching lines @@
   return 1;
 }
 
 void RenderWidgetHostViewWin::UpdateIMEState() {
   if (base::win::IsTSFAwareRequired()) {
     ui::TSFBridge::GetInstance()->OnTextInputTypeChanged(this);
     return;
   }
   if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE &&
       text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD) {
-    imm32_manager_.EnableIME(m_hWnd);
-    imm32_manager_.SetUseCompositionWindow(!can_compose_inline_);
+    imm32_manager_->EnableIME(m_hWnd);
+    imm32_manager_->SetUseCompositionWindow(!can_compose_inline_);
   } else {
-    imm32_manager_.DisableIME(m_hWnd);
+    imm32_manager_->DisableIME(m_hWnd);
   }
 }
 
 void RenderWidgetHostViewWin::UpdateInputScopeIfNecessary(
     ui::TextInputType text_input_type) {
   // The text store is responsible for handling input scope when TSF-aware is
   // required.
   if (base::win::IsTSFAwareRequired())
     return;
 
@@ skipping 10 matching lines @@
   return new RenderWidgetHostViewWin(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
       WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(0, results);
 }
 
 }  // namespace content