Support InputMethodManager#updateCursorAnchorInfo for Android 5.0 (C++ version)

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 54 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/android/window_android.h"
 #include "ui/base/android/window_android_compositor.h"
+#include "ui/base/ime/android/cursor_anchor_info_builder.h"
+#include "ui/base/ime/android/cursor_anchor_info_controller.h"
 #include "ui/events/gesture_detection/gesture_provider_config_helper.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/android/view_configuration.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/touch_selection/touch_selection_controller.h"
@@ skipping 241 matching lines @@
 }
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       outstanding_vsync_requests_(0),
       is_showing_(!widget_host->is_hidden()),
       content_view_core_(NULL),
       ime_adapter_android_(this),
+      cursor_anchor_info_controller_(
+          ui::CursorAnchorInfoController::Create(this)),
       cached_background_color_(SK_ColorWHITE),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       gesture_provider_(CreateGestureProviderConfig(), this),
       stylus_text_selector_(this),
       accelerated_surface_route_id_(0),
       using_browser_compositor_(CompositorImpl::IsInitialized()),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false),
       weak_ptr_factory_(this) {
@@ skipping 355 matching lines @@
     ui::TextInputMode input_mode,
     bool can_compose_inline,
     int flags) {
   // Unused on Android, which uses OnTextInputChanged instead.
 }
 
 long RenderWidgetHostViewAndroid::GetNativeImeAdapter() {
   return reinterpret_cast<intptr_t>(&ime_adapter_android_);
 }
 
+bool RenderWidgetHostViewAndroid::RequestCursorUpdates(
+    uint32 cursor_update_mode) {
+  if (!cursor_anchor_info_controller_)
+    return false;
+
+  return cursor_anchor_info_controller_->OnRequestCursorUpdates(
+      cursor_update_mode);
+}
+
 void RenderWidgetHostViewAndroid::OnTextInputStateChanged(
     const ViewHostMsg_TextInputState_Params& params) {
   if (selection_controller_) {
     // This call is semi-redundant with that in |OnFocusedNodeChanged|. The
     // latter is guaranteed to be called before |OnSelectionBoundsChanged|,
     // while this call is present to ensure consistency with IME after
     // navigation and tab focus changes
     const bool is_editable_node = params.type != ui::TEXT_INPUT_TYPE_NONE;
     selection_controller_->OnSelectionEditable(is_editable_node);
   }
 
   // If the change is not originated from IME (e.g. Javascript, autofill),
   // send back the renderer an acknowledgement, regardless of how we exit from
   // this method.
   base::ScopedClosureRunner ack_caller;
   if (params.is_non_ime_change)
     ack_caller.Reset(base::Bind(&SendImeEventAck, host_));
 
   if (!IsShowing())
     return;
 
   content_view_core_->UpdateImeAdapter(
       GetNativeImeAdapter(),
       static_cast<int>(params.type), params.flags,
       params.value, params.selection_start, params.selection_end,
       params.composition_start, params.composition_end,
       params.show_ime_if_needed, params.is_non_ime_change);
+
+  if (cursor_anchor_info_controller_) {
+    cursor_anchor_info_controller_->OnTextInputStateChanged(
+        base::UTF8ToUTF16(params.value),
+        gfx::Range(params.selection_start, params.selection_end),
+        gfx::Range(params.composition_start, params.composition_end));
+  }
 }
 
 void RenderWidgetHostViewAndroid::OnDidChangeBodyBackgroundColor(
     SkColor color) {
   if (cached_background_color_ == color)
     return;
 
   cached_background_color_ = color;
   if (content_view_core_)
     content_view_core_->OnBackgroundColorChanged(color);
@@ skipping 85 matching lines @@
   gesture_provider_.SetMultiTouchZoomSupportEnabled(enabled);
 }
 
 void RenderWidgetHostViewAndroid::ImeCancelComposition() {
   ime_adapter_android_.CancelComposition();
 }
 
 void RenderWidgetHostViewAndroid::ImeCompositionRangeChanged(
     const gfx::Range& range,
     const std::vector<gfx::Rect>& character_bounds) {
-  // TODO(yukawa): Implement this.
+  if (cursor_anchor_info_controller_) {
+    cursor_anchor_info_controller_->OnCompositionRangeChanged(range,
+                                                              character_bounds);
+  }
 }
 
 void RenderWidgetHostViewAndroid::FocusedNodeChanged(bool is_editable_node) {
   ime_adapter_android_.FocusedNodeChanged(is_editable_node);
+  if (cursor_anchor_info_controller_)
+    cursor_anchor_info_controller_->OnFocusedNodeChanged(is_editable_node);
   if (selection_controller_)
     selection_controller_->OnSelectionEditable(is_editable_node);
 }
 
 void RenderWidgetHostViewAndroid::RenderProcessGone(
     base::TerminationStatus status, int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
@@ skipping 157 matching lines @@
   host_->Send(new ViewMsg_ReclaimCompositorResources(host_->GetRoutingID(),
                                                      output_surface_id, ack));
 }
 
 void RenderWidgetHostViewAndroid::UnusedResourcesAreAvailable() {
   if (ack_callbacks_.size())
     return;
   SendReturnedDelegatedResources(last_output_surface_id_);
 }
 
+void RenderWidgetHostViewAndroid::SendCursorAnchorInfo(
+    ui::CursorAnchorInfoBuilder* builder) {
+  ime_adapter_android_.UpdateCursorAnchorInfo(builder->Build());
+}
+
 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
   RemoveLayers();
   frame_provider_ = NULL;
   layer_ = NULL;
   // This gets called when ever any eviction, loosing resources, swapping
   // problems are encountered and so we abort any pending readbacks here.
   AbortPendingReadbackRequests();
 }
 
 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
@@ skipping 304 matching lines @@
 #if defined(VIDEO_HOLE)
   if (host_ && host_->IsRenderView()) {
     RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(
         RenderViewHost::From(host_));
     WebContentsImpl* web_contents_impl =
         static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvhi));
     if (web_contents_impl)
       web_contents_impl->media_web_contents_observer()->OnFrameInfoUpdated();
   }
 #endif  // defined(VIDEO_HOLE)
+
+  if (cursor_anchor_info_controller_) {
+    cursor_anchor_info_controller_->OnFrameMetadataUpdated(
+        frame_metadata, content_view_core_->GetLocationOnScreen());
+  }
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceInitialized(int route_id) {
   // TODO: remove need for the surface id here
   accelerated_surface_route_id_ = route_id;
 }
 
 void RenderWidgetHostViewAndroid::AttachLayers() {
   if (!content_view_core_)
     return;
@@ skipping 553 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content