content/browser/renderer_host/render_widget_host_view_android.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/render_widget_host_view_android.h"
   6
   7 #include <android/bitmap.h>
   8
   9 #include "base/android/build_info.h"
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/callback_helpers.h"
  13 #include "base/command_line.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/sys_info.h"
  19 #include "base/threading/worker_pool.h"
  20 #include "cc/layers/delegated_frame_provider.h"
  21 #include "cc/layers/delegated_renderer_layer.h"
  22 #include "cc/layers/layer.h"
  23 #include "cc/layers/surface_layer.h"
  24 #include "cc/output/compositor_frame.h"
  25 #include "cc/output/compositor_frame_ack.h"
  26 #include "cc/output/copy_output_request.h"
  27 #include "cc/output/copy_output_result.h"
  28 #include "cc/output/latency_info_swap_promise.h"
  29 #include "cc/output/viewport_selection_bound.h"
  30 #include "cc/resources/single_release_callback.h"
  31 #include "cc/surfaces/surface.h"
  32 #include "cc/surfaces/surface_factory.h"
  33 #include "cc/surfaces/surface_id_allocator.h"
  34 #include "cc/surfaces/surface_manager.h"
  35 #include "cc/trees/layer_tree_host.h"
  36 #include "content/browser/accessibility/browser_accessibility_manager_android.h"
  37 #include "content/browser/android/composited_touch_handle_drawable.h"
  38 #include "content/browser/android/content_view_core_impl.h"
  39 #include "content/browser/android/edge_effect.h"
  40 #include "content/browser/android/edge_effect_l.h"
  41 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
  42 #include "content/browser/android/overscroll_controller_android.h"
  43 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
  44 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
  45 #include "content/browser/gpu/compositor_util.h"
  46 #include "content/browser/gpu/gpu_data_manager_impl.h"
  47 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
  48 #include "content/browser/gpu/gpu_surface_tracker.h"
  49 #include "content/browser/media/media_web_contents_observer.h"
  50 #include "content/browser/renderer_host/compositor_impl_android.h"
  51 #include "content/browser/renderer_host/dip_util.h"
  52 #include "content/browser/renderer_host/frame_metadata_util.h"
  53 #include "content/browser/renderer_host/input/synthetic_gesture_target_android.h"
  54 #include "content/browser/renderer_host/input/ui_touch_selection_helper.h"
  55 #include "content/browser/renderer_host/input/web_input_event_builders_android.h"
  56 #include "content/browser/renderer_host/input/web_input_event_util.h"
  57 #include "content/browser/renderer_host/render_process_host_impl.h"
  58 #include "content/browser/renderer_host/render_view_host_impl.h"
  59 #include "content/browser/renderer_host/render_widget_host_impl.h"
  60 #include "content/common/gpu/client/gl_helper.h"
  61 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
  62 #include "content/common/gpu/gpu_messages.h"
  63 #include "content/common/gpu/gpu_process_launch_causes.h"
  64 #include "content/common/input/did_overscroll_params.h"
  65 #include "content/common/input_messages.h"
  66 #include "content/common/view_messages.h"
  67 #include "content/public/browser/android/compositor.h"
  68 #include "content/public/browser/browser_thread.h"
  69 #include "content/public/browser/devtools_agent_host.h"
  70 #include "content/public/browser/render_view_host.h"
  71 #include "content/public/browser/render_widget_host_iterator.h"
  72 #include "content/public/common/content_switches.h"
  73 #include "gpu/command_buffer/client/gles2_implementation.h"
  74 #include "gpu/command_buffer/client/gles2_interface.h"
  75 #include "gpu/config/gpu_driver_bug_workaround_type.h"
  76 #include "skia/ext/image_operations.h"
  77 #include "third_party/khronos/GLES2/gl2.h"
  78 #include "third_party/khronos/GLES2/gl2ext.h"
  79 #include "third_party/skia/include/core/SkCanvas.h"
  80 #include "ui/android/window_android.h"
  81 #include "ui/android/window_android_compositor.h"
  82 #include "ui/events/blink/blink_event_util.h"
  83 #include "ui/events/gesture_detection/gesture_provider_config_helper.h"
  84 #include "ui/events/gesture_detection/motion_event.h"
  85 #include "ui/gfx/android/device_display_info.h"
  86 #include "ui/gfx/android/java_bitmap.h"
  87 #include "ui/gfx/android/view_configuration.h"
  88 #include "ui/gfx/display.h"
  89 #include "ui/gfx/geometry/dip_util.h"
  90 #include "ui/gfx/geometry/size_conversions.h"
  91 #include "ui/gfx/screen.h"
  92 #include "ui/touch_selection/touch_selection_controller.h"
  93
  94 namespace content {
  95
  96 namespace {
  97
  98 void SatisfyCallback(cc::SurfaceManager* manager,
  99                      cc::SurfaceSequence sequence) {
 100   std::vector<uint32_t> sequences;
 101   sequences.push_back(sequence.sequence);
 102   manager->DidSatisfySequences(sequence.id_namespace, &sequences);
 103 }
 104
 105 void RequireCallback(cc::SurfaceManager* manager,
 106                      cc::SurfaceId id,
 107                      cc::SurfaceSequence sequence) {
 108   cc::Surface* surface = manager->GetSurfaceForId(id);
 109   if (!surface) {
 110     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
 111     return;
 112   }
 113   surface->AddDestructionDependency(sequence);
 114 }
 115
 116 const int kUndefinedOutputSurfaceId = -1;
 117
 118 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 119
 120 // Sends an acknowledgement to the renderer of a processed IME event.
 121 void SendImeEventAck(RenderWidgetHostImpl* host) {
 122   host->Send(new ViewMsg_ImeEventAck(host->GetRoutingID()));
 123 }
 124
 125 class GLHelperHolder
 126     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
 127  public:
 128   static GLHelperHolder* Create();
 129   ~GLHelperHolder() override;
 130
 131   void Initialize();
 132
 133   // WebGraphicsContextLostCallback implementation.
 134   void onContextLost() override;
 135
 136   GLHelper* GetGLHelper() { return gl_helper_.get(); }
 137   bool IsLost() { return !context_.get() || context_->isContextLost(); }
 138
 139  private:
 140   GLHelperHolder();
 141   static scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateContext3D();
 142
 143   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context_;
 144   scoped_ptr<GLHelper> gl_helper_;
 145
 146   DISALLOW_COPY_AND_ASSIGN(GLHelperHolder);
 147 };
 148
 149 GLHelperHolder* GLHelperHolder::Create() {
 150   GLHelperHolder* holder = new GLHelperHolder;
 151   holder->Initialize();
 152
 153   return holder;
 154 }
 155
 156 GLHelperHolder::GLHelperHolder() {
 157 }
 158
 159 GLHelperHolder::~GLHelperHolder() {
 160 }
 161
 162 void GLHelperHolder::Initialize() {
 163   context_ = CreateContext3D();
 164   if (context_) {
 165     context_->setContextLostCallback(this);
 166     gl_helper_.reset(new GLHelper(context_->GetImplementation(),
 167                                   context_->GetContextSupport()));
 168   }
 169 }
 170
 171 void GLHelperHolder::onContextLost() {
 172   // Need to post a task because the command buffer client cannot be deleted
 173   // from within this callback.
 174   LOG(ERROR) << "Context lost.";
 175   base::MessageLoop::current()->PostTask(
 176       FROM_HERE,
 177       base::Bind(&RenderWidgetHostViewAndroid::OnContextLost));
 178 }
 179
 180 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 181 GLHelperHolder::CreateContext3D() {
 182   BrowserGpuChannelHostFactory* factory =
 183       BrowserGpuChannelHostFactory::instance();
 184   scoped_refptr<GpuChannelHost> gpu_channel_host(factory->GetGpuChannel());
 185   // GLHelper can only be used in asynchronous APIs for postprocessing after
 186   // Browser Compositor operations (i.e. readback).
 187   if (!gpu_channel_host.get()) {
 188     // The Browser Compositor is in charge of reestablishing the channel.
 189     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
 190   }
 191
 192   blink::WebGraphicsContext3D::Attributes attrs;
 193   attrs.shareResources = true;
 194   GURL url("chrome://gpu/RenderWidgetHostViewAndroid");
 195   static const size_t kBytesPerPixel = 4;
 196   gfx::DeviceDisplayInfo display_info;
 197   size_t full_screen_texture_size_in_bytes = display_info.GetDisplayHeight() *
 198                                              display_info.GetDisplayWidth() *
 199                                              kBytesPerPixel;
 200   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
 201   limits.command_buffer_size = 64 * 1024;
 202   limits.start_transfer_buffer_size = 64 * 1024;
 203   limits.min_transfer_buffer_size = 64 * 1024;
 204   limits.max_transfer_buffer_size = std::min(
 205       3 * full_screen_texture_size_in_bytes, kDefaultMaxTransferBufferSize);
 206   limits.mapped_memory_reclaim_limit =
 207       WebGraphicsContext3DCommandBufferImpl::kNoLimit;
 208   bool lose_context_when_out_of_memory = false;
 209   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
 210       new WebGraphicsContext3DCommandBufferImpl(
 211           0,  // offscreen
 212           url, gpu_channel_host.get(), attrs, lose_context_when_out_of_memory,
 213           limits, nullptr));
 214   context->SetContextType(BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
 215   if (context->InitializeOnCurrentThread()) {
 216     context->traceBeginCHROMIUM(
 217         "gpu_toplevel",
 218         base::StringPrintf("CmdBufferImageTransportFactory-%p",
 219                            context.get()).c_str());
 220   } else {
 221     context.reset();
 222   }
 223
 224   return context.Pass();
 225 }
 226
 227 // This can only be used for readback postprocessing. It may return null if the
 228 // channel was lost and not reestablished yet.
 229 GLHelper* GetPostReadbackGLHelper() {
 230   static GLHelperHolder* g_readback_helper_holder = nullptr;
 231
 232   if (g_readback_helper_holder && g_readback_helper_holder->IsLost()) {
 233     delete g_readback_helper_holder;
 234     g_readback_helper_holder = nullptr;
 235   }
 236
 237   if (!g_readback_helper_holder)
 238     g_readback_helper_holder = GLHelperHolder::Create();
 239
 240   return g_readback_helper_holder->GetGLHelper();
 241 }
 242
 243 void CopyFromCompositingSurfaceFinished(
 244     ReadbackRequestCallback& callback,
 245     scoped_ptr<cc::SingleReleaseCallback> release_callback,
 246     scoped_ptr<SkBitmap> bitmap,
 247     const base::TimeTicks& start_time,
 248     scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock,
 249     bool result) {
 250   TRACE_EVENT0(
 251       "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
 252   bitmap_pixels_lock.reset();
 253   uint32 sync_point = 0;
 254   if (result) {
 255     GLHelper* gl_helper = GetPostReadbackGLHelper();
 256     if (gl_helper)
 257       sync_point = gl_helper->InsertSyncPoint();
 258   }
 259   bool lost_resource = sync_point == 0;
 260   release_callback->Run(sync_point, lost_resource);
 261   UMA_HISTOGRAM_TIMES(kAsyncReadBackString,
 262                       base::TimeTicks::Now() - start_time);
 263   ReadbackResponse response = result ? READBACK_SUCCESS : READBACK_FAILED;
 264   callback.Run(*bitmap, response);
 265 }
 266
 267 scoped_ptr<ui::TouchSelectionController> CreateSelectionController(
 268     ui::TouchSelectionControllerClient* client,
 269     ContentViewCore* content_view_core) {
 270   DCHECK(client);
 271   DCHECK(content_view_core);
 272   ui::TouchSelectionController::Config config;
 273   config.tap_timeout = base::TimeDelta::FromMilliseconds(
 274       gfx::ViewConfiguration::GetTapTimeoutInMs());
 275   config.tap_slop = gfx::ViewConfiguration::GetTouchSlopInDips();
 276   config.show_on_tap_for_empty_editable = false;
 277   config.enable_longpress_drag_selection =
 278       base::CommandLine::ForCurrentProcess()->HasSwitch(
 279           switches::kEnableLongpressDragSelection);
 280   return make_scoped_ptr(new ui::TouchSelectionController(client, config));
 281 }
 282
 283 scoped_ptr<OverscrollControllerAndroid> CreateOverscrollController(
 284     ContentViewCoreImpl* content_view_core) {
 285   return make_scoped_ptr(new OverscrollControllerAndroid(content_view_core));
 286 }
 287
 288 ui::GestureProvider::Config CreateGestureProviderConfig() {
 289   ui::GestureProvider::Config config = ui::GetGestureProviderConfig(
 290       ui::GestureProviderConfigType::CURRENT_PLATFORM);
 291   config.disable_click_delay =
 292       base::CommandLine::ForCurrentProcess()->HasSwitch(
 293           switches::kDisableClickDelay);
 294   return config;
 295 }
 296
 297 gfx::RectF GetSelectionRect(const ui::TouchSelectionController& controller) {
 298   gfx::RectF rect = controller.GetRectBetweenBounds();
 299   if (rect.IsEmpty())
 300     return rect;
 301
 302   rect.Union(controller.GetStartHandleRect());
 303   rect.Union(controller.GetEndHandleRect());
 304   return rect;
 305 }
 306
 307 }  // anonymous namespace
 308
 309 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo(
 310     uint32 output_id,
 311     scoped_ptr<cc::CompositorFrame> output_frame)
 312     : output_surface_id(output_id), frame(output_frame.Pass()) {}
 313
 314 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 315
 316 void RenderWidgetHostViewAndroid::OnContextLost() {
 317   scoped_ptr<RenderWidgetHostIterator> widgets(
 318       RenderWidgetHostImpl::GetAllRenderWidgetHosts());
 319   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
 320     if (widget->GetView()) {
 321       static_cast<RenderWidgetHostViewAndroid*>(widget->GetView())
 322           ->OnLostResources();
 323     }
 324   }
 325 }
 326
 327 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
 328     RenderWidgetHostImpl* widget_host,
 329     ContentViewCoreImpl* content_view_core)
 330     : host_(widget_host),
 331       outstanding_vsync_requests_(0),
 332       is_showing_(!widget_host->is_hidden()),
 333       content_view_core_(nullptr),
 334       content_view_core_window_android_(nullptr),
 335       ime_adapter_android_(this),
 336       cached_background_color_(SK_ColorWHITE),
 337       last_output_surface_id_(kUndefinedOutputSurfaceId),
 338       gesture_provider_(CreateGestureProviderConfig(), this),
 339       stylus_text_selector_(this),
 340       accelerated_surface_route_id_(0),
 341       using_browser_compositor_(CompositorImpl::IsInitialized()),
 342       frame_evictor_(new DelegatedFrameEvictor(this)),
 343       locks_on_frame_count_(0),
 344       observing_root_window_(false),
 345       weak_ptr_factory_(this) {
 346   if (CompositorImpl::GetSurfaceManager())
 347     id_allocator_ = CompositorImpl::CreateSurfaceIdAllocator();
 348   host_->SetView(this);
 349   SetContentViewCore(content_view_core);
 350 }
 351
 352 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
 353   SetContentViewCore(NULL);
 354   DCHECK(ack_callbacks_.empty());
 355   if (resource_collection_.get())
 356     resource_collection_->SetClient(NULL);
 357   DCHECK(!surface_factory_);
 358   DCHECK(surface_id_.is_null());
 359 }
 360
 361 void RenderWidgetHostViewAndroid::Blur() {
 362   host_->Blur();
 363   if (overscroll_controller_)
 364     overscroll_controller_->Disable();
 365 }
 366
 367 bool RenderWidgetHostViewAndroid::OnMessageReceived(
 368     const IPC::Message& message) {
 369   bool handled = true;
 370   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewAndroid, message)
 371     IPC_MESSAGE_HANDLER(ViewHostMsg_StartContentIntent, OnStartContentIntent)
 372     IPC_MESSAGE_HANDLER(ViewHostMsg_DidChangeBodyBackgroundColor,
 373                         OnDidChangeBodyBackgroundColor)
 374     IPC_MESSAGE_HANDLER(ViewHostMsg_SetNeedsBeginFrames,
 375                         OnSetNeedsBeginFrames)
 376     IPC_MESSAGE_HANDLER(ViewHostMsg_TextInputStateChanged,
 377                         OnTextInputStateChanged)
 378     IPC_MESSAGE_HANDLER(ViewHostMsg_SmartClipDataExtracted,
 379                         OnSmartClipDataExtracted)
 380     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowUnhandledTapUIIfNeeded,
 381                         OnShowUnhandledTapUIIfNeeded)
 382     IPC_MESSAGE_UNHANDLED(handled = false)
 383   IPC_END_MESSAGE_MAP()
 384   return handled;
 385 }
 386
 387 void RenderWidgetHostViewAndroid::InitAsChild(gfx::NativeView parent_view) {
 388   NOTIMPLEMENTED();
 389 }
 390
 391 void RenderWidgetHostViewAndroid::InitAsPopup(
 392     RenderWidgetHostView* parent_host_view, const gfx::Rect& pos) {
 393   NOTIMPLEMENTED();
 394 }
 395
 396 void RenderWidgetHostViewAndroid::InitAsFullscreen(
 397     RenderWidgetHostView* reference_host_view) {
 398   NOTIMPLEMENTED();
 399 }
 400
 401 RenderWidgetHost*
 402 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
 403   return host_;
 404 }
 405
 406 void RenderWidgetHostViewAndroid::WasResized() {
 407   host_->WasResized();
 408 }
 409
 410 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
 411   // Ignore the given size as only the Java code has the power to
 412   // resize the view on Android.
 413   default_size_ = size;
 414 }
 415
 416 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
 417   SetSize(rect.size());
 418 }
 419
 420 void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
 421     float scale,
 422     SkColorType preferred_color_type,
 423     gfx::Rect src_subrect,
 424     ReadbackRequestCallback& result_callback) {
 425   if (!host_ || host_->is_hidden() || !IsSurfaceAvailableForCopy()) {
 426     result_callback.Run(SkBitmap(), READBACK_SURFACE_UNAVAILABLE);
 427     return;
 428   }
 429   gfx::Size bounds = layer_->bounds();
 430   if (src_subrect.IsEmpty())
 431     src_subrect = gfx::Rect(bounds);
 432   DCHECK_LE(src_subrect.width() + src_subrect.x(), bounds.width());
 433   DCHECK_LE(src_subrect.height() + src_subrect.y(), bounds.height());
 434   const gfx::Display& display =
 435       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
 436   float device_scale_factor = display.device_scale_factor();
 437   DCHECK_GT(device_scale_factor, 0);
 438   gfx::Size dst_size(gfx::ToCeiledSize(
 439       gfx::ScaleSize(src_subrect.size(), scale / device_scale_factor)));
 440   src_subrect = gfx::ConvertRectToDIP(device_scale_factor, src_subrect);
 441
 442   CopyFromCompositingSurface(src_subrect, dst_size, result_callback,
 443                              preferred_color_type);
 444 }
 445
 446 scoped_refptr<cc::Layer> RenderWidgetHostViewAndroid::CreateDelegatedLayer()
 447     const {
 448   scoped_refptr<cc::Layer> delegated_layer;
 449   if (!surface_id_.is_null()) {
 450     cc::SurfaceManager* manager = CompositorImpl::GetSurfaceManager();
 451     DCHECK(manager);
 452     // manager must outlive compositors using it.
 453     scoped_refptr<cc::SurfaceLayer> surface_layer = cc::SurfaceLayer::Create(
 454         Compositor::LayerSettings(),
 455         base::Bind(&SatisfyCallback, base::Unretained(manager)),
 456         base::Bind(&RequireCallback, base::Unretained(manager)));
 457     surface_layer->SetSurfaceId(surface_id_, 1.f, texture_size_in_layer_);
 458     delegated_layer = surface_layer;
 459   } else {
 460     DCHECK(frame_provider_.get());
 461     delegated_layer = cc::DelegatedRendererLayer::Create(
 462         Compositor::LayerSettings(), frame_provider_);
 463   }
 464   delegated_layer->SetBounds(content_size_in_layer_);
 465   delegated_layer->SetIsDrawable(true);
 466   delegated_layer->SetContentsOpaque(true);
 467
 468   return delegated_layer;
 469 }
 470
 471 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
 472   if (!content_view_core_)
 473     return false;
 474   if (!layer_.get())
 475     return false;
 476
 477   if (texture_size_in_layer_.IsEmpty())
 478     return false;
 479   // This tell us whether a valid frame has arrived or not.
 480   if (!frame_evictor_->HasFrame())
 481     return false;
 482
 483   return true;
 484 }
 485
 486 gfx::Vector2dF RenderWidgetHostViewAndroid::GetLastScrollOffset() const {
 487   return last_scroll_offset_;
 488 }
 489
 490 gfx::NativeView RenderWidgetHostViewAndroid::GetNativeView() const {
 491   return content_view_core_->GetViewAndroid();
 492 }
 493
 494 gfx::NativeViewId RenderWidgetHostViewAndroid::GetNativeViewId() const {
 495   return reinterpret_cast<gfx::NativeViewId>(
 496       const_cast<RenderWidgetHostViewAndroid*>(this));
 497 }
 498
 499 gfx::NativeViewAccessible
 500 RenderWidgetHostViewAndroid::GetNativeViewAccessible() {
 501   NOTIMPLEMENTED();
 502   return NULL;
 503 }
 504
 505 void RenderWidgetHostViewAndroid::MovePluginWindows(
 506     const std::vector<WebPluginGeometry>& moves) {
 507   // We don't have plugin windows on Android. Do nothing. Note: this is called
 508   // from RenderWidgetHost::OnUpdateRect which is itself invoked while
 509   // processing the corresponding message from Renderer.
 510 }
 511
 512 void RenderWidgetHostViewAndroid::Focus() {
 513   host_->Focus();
 514   if (overscroll_controller_)
 515     overscroll_controller_->Enable();
 516   if (content_view_core_) {
 517     WebContentsImpl* web_contents_impl =
 518         static_cast<WebContentsImpl*>(content_view_core_->GetWebContents());
 519     if (web_contents_impl->ShowingInterstitialPage())
 520       content_view_core_->ForceUpdateImeAdapter(GetNativeImeAdapter());
 521   }
 522 }
 523
 524 bool RenderWidgetHostViewAndroid::HasFocus() const {
 525   if (!content_view_core_)
 526     return false;  // ContentViewCore not created yet.
 527
 528   return content_view_core_->HasFocus();
 529 }
 530
 531 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
 532   return HasValidFrame();
 533 }
 534
 535 void RenderWidgetHostViewAndroid::Show() {
 536   if (is_showing_)
 537     return;
 538
 539   is_showing_ = true;
 540   ShowInternal();
 541 }
 542
 543 void RenderWidgetHostViewAndroid::Hide() {
 544   if (!is_showing_)
 545     return;
 546
 547   is_showing_ = false;
 548
 549   bool hide_frontbuffer = true;
 550   bool stop_observing_root_window = true;
 551   HideInternal(hide_frontbuffer, stop_observing_root_window);
 552 }
 553
 554 bool RenderWidgetHostViewAndroid::IsShowing() {
 555   // ContentViewCoreImpl represents the native side of the Java
 556   // ContentViewCore.  It being NULL means that it is not attached
 557   // to the View system yet, so we treat this RWHVA as hidden.
 558   return is_showing_ && content_view_core_;
 559 }
 560
 561 void RenderWidgetHostViewAndroid::LockCompositingSurface() {
 562   DCHECK(HasValidFrame());
 563   DCHECK(host_);
 564   DCHECK(frame_evictor_->HasFrame());
 565   frame_evictor_->LockFrame();
 566   locks_on_frame_count_++;
 567 }
 568
 569 void RenderWidgetHostViewAndroid::UnlockCompositingSurface() {
 570   if (!frame_evictor_->HasFrame() || locks_on_frame_count_ == 0)
 571     return;
 572
 573   DCHECK(HasValidFrame());
 574   frame_evictor_->UnlockFrame();
 575   locks_on_frame_count_--;
 576
 577   if (locks_on_frame_count_ == 0) {
 578     if (last_frame_info_) {
 579       InternalSwapCompositorFrame(last_frame_info_->output_surface_id,
 580                                   last_frame_info_->frame.Pass());
 581       last_frame_info_.reset();
 582     }
 583
 584     if (!is_showing_ && layer_.get())
 585       layer_->SetHideLayerAndSubtree(true);
 586   }
 587 }
 588
 589 void RenderWidgetHostViewAndroid::SetTextSurroundingSelectionCallback(
 590     const TextSurroundingSelectionCallback& callback) {
 591   // Only one outstanding request is allowed at any given time.
 592   DCHECK(!callback.is_null());
 593   text_surrounding_selection_callback_ = callback;
 594 }
 595
 596 void RenderWidgetHostViewAndroid::OnTextSurroundingSelectionResponse(
 597     const base::string16& content,
 598     size_t start_offset,
 599     size_t end_offset) {
 600   if (text_surrounding_selection_callback_.is_null())
 601     return;
 602   text_surrounding_selection_callback_.Run(content, start_offset, end_offset);
 603   text_surrounding_selection_callback_.Reset();
 604 }
 605
 606 void RenderWidgetHostViewAndroid::OnShowUnhandledTapUIIfNeeded(int x_dip,
 607                                                                int y_dip) {
 608   if (!content_view_core_)
 609     return;
 610   // Validate the coordinates are within the viewport.
 611   gfx::Size viewport_size = content_view_core_->GetViewportSizeDip();
 612   if (x_dip < 0 || x_dip > viewport_size.width() ||
 613       y_dip < 0 || y_dip > viewport_size.height())
 614     return;
 615   content_view_core_->OnShowUnhandledTapUIIfNeeded(x_dip, y_dip);
 616 }
 617
 618 void RenderWidgetHostViewAndroid::ReleaseLocksOnSurface() {
 619   if (!frame_evictor_->HasFrame()) {
 620     DCHECK_EQ(locks_on_frame_count_, 0u);
 621     return;
 622   }
 623   while (locks_on_frame_count_ > 0) {
 624     UnlockCompositingSurface();
 625   }
 626   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
 627 }
 628
 629 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
 630   if (!content_view_core_)
 631     return gfx::Rect(default_size_);
 632
 633   return gfx::Rect(content_view_core_->GetViewSize());
 634 }
 635
 636 gfx::Size RenderWidgetHostViewAndroid::GetPhysicalBackingSize() const {
 637   if (!content_view_core_)
 638     return gfx::Size();
 639
 640   return content_view_core_->GetPhysicalBackingSize();
 641 }
 642
 643 bool RenderWidgetHostViewAndroid::DoTopControlsShrinkBlinkSize() const {
 644   if (!content_view_core_)
 645     return false;
 646
 647   // Whether or not Blink's viewport size should be shrunk by the height of the
 648   // URL-bar.
 649   return content_view_core_->DoTopControlsShrinkBlinkSize();
 650 }
 651
 652 float RenderWidgetHostViewAndroid::GetTopControlsHeight() const {
 653   if (!content_view_core_)
 654     return 0.f;
 655
 656   // The height of the top controls.
 657   return content_view_core_->GetTopControlsHeightDip();
 658 }
 659
 660 void RenderWidgetHostViewAndroid::UpdateCursor(const WebCursor& cursor) {
 661   // There are no cursors on Android.
 662 }
 663
 664 void RenderWidgetHostViewAndroid::SetIsLoading(bool is_loading) {
 665   // Do nothing. The UI notification is handled through ContentViewClient which
 666   // is TabContentsDelegate.
 667 }
 668
 669 void RenderWidgetHostViewAndroid::TextInputTypeChanged(
 670     ui::TextInputType type,
 671     ui::TextInputMode input_mode,
 672     bool can_compose_inline,
 673     int flags) {
 674   // Unused on Android, which uses OnTextInputChanged instead.
 675 }
 676
 677 long RenderWidgetHostViewAndroid::GetNativeImeAdapter() {
 678   return reinterpret_cast<intptr_t>(&ime_adapter_android_);
 679 }
 680
 681 void RenderWidgetHostViewAndroid::OnTextInputStateChanged(
 682     const ViewHostMsg_TextInputState_Params& params) {
 683   // If the change is not originated from IME (e.g. Javascript, autofill),
 684   // send back the renderer an acknowledgement, regardless of how we exit from
 685   // this method.
 686   base::ScopedClosureRunner ack_caller;
 687   if (params.is_non_ime_change)
 688     ack_caller.Reset(base::Bind(&SendImeEventAck, host_));
 689
 690   if (!IsShowing())
 691     return;
 692
 693   content_view_core_->UpdateImeAdapter(
 694       GetNativeImeAdapter(),
 695       static_cast<int>(params.type), params.flags,
 696       params.value, params.selection_start, params.selection_end,
 697       params.composition_start, params.composition_end,
 698       params.show_ime_if_needed, params.is_non_ime_change);
 699 }
 700
 701 void RenderWidgetHostViewAndroid::OnDidChangeBodyBackgroundColor(
 702     SkColor color) {
 703   if (cached_background_color_ == color)
 704     return;
 705
 706   cached_background_color_ = color;
 707   if (content_view_core_)
 708     content_view_core_->OnBackgroundColorChanged(color);
 709 }
 710
 711 void RenderWidgetHostViewAndroid::OnSetNeedsBeginFrames(bool enabled) {
 712   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::OnSetNeedsBeginFrames",
 713                "enabled", enabled);
 714   if (enabled)
 715     RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
 716   else
 717     outstanding_vsync_requests_ &= ~PERSISTENT_BEGIN_FRAME;
 718 }
 719
 720 void RenderWidgetHostViewAndroid::OnStartContentIntent(
 721     const GURL& content_url) {
 722   if (content_view_core_)
 723     content_view_core_->StartContentIntent(content_url);
 724 }
 725
 726 void RenderWidgetHostViewAndroid::OnSmartClipDataExtracted(
 727     const base::string16& text,
 728     const base::string16& html,
 729     const gfx::Rect rect) {
 730   if (content_view_core_)
 731     content_view_core_->OnSmartClipDataExtracted(text, html, rect);
 732 }
 733
 734 bool RenderWidgetHostViewAndroid::OnTouchEvent(
 735     const ui::MotionEvent& event) {
 736   if (!host_)
 737     return false;
 738
 739   // If a browser-based widget consumes the touch event, it's critical that
 740   // touch event interception be disabled. This avoids issues with
 741   // double-handling for embedder-detected gestures like side swipe.
 742   if (selection_controller_ &&
 743       selection_controller_->WillHandleTouchEvent(event)) {
 744     RequestDisallowInterceptTouchEvent();
 745     return true;
 746   }
 747
 748   if (stylus_text_selector_.OnTouchEvent(event)) {
 749     RequestDisallowInterceptTouchEvent();
 750     return true;
 751   }
 752
 753   ui::FilteredGestureProvider::TouchHandlingResult result =
 754       gesture_provider_.OnTouchEvent(event);
 755   if (!result.succeeded)
 756     return false;
 757
 758   blink::WebTouchEvent web_event =
 759       ui::CreateWebTouchEventFromMotionEvent(event, result.did_generate_scroll);
 760   host_->ForwardTouchEventWithLatencyInfo(web_event, ui::LatencyInfo());
 761
 762   // Send a proactive BeginFrame for this vsync to reduce scroll latency for
 763   // scroll-inducing touch events. Note that Android's Choreographer ensures
 764   // that BeginFrame requests made during ACTION_MOVE dispatch will be honored
 765   // in the same vsync phase.
 766   if (observing_root_window_&& result.did_generate_scroll)
 767     RequestVSyncUpdate(BEGIN_FRAME);
 768
 769   return true;
 770 }
 771
 772 bool RenderWidgetHostViewAndroid::OnTouchHandleEvent(
 773     const ui::MotionEvent& event) {
 774   return selection_controller_ &&
 775          selection_controller_->WillHandleTouchEvent(event);
 776 }
 777
 778 void RenderWidgetHostViewAndroid::ResetGestureDetection() {
 779   const ui::MotionEvent* current_down_event =
 780       gesture_provider_.GetCurrentDownEvent();
 781   if (!current_down_event) {
 782     // A hard reset ensures prevention of any timer-based events that might fire
 783     // after a touch sequence has ended.
 784     gesture_provider_.ResetDetection();
 785     return;
 786   }
 787
 788   scoped_ptr<ui::MotionEvent> cancel_event = current_down_event->Cancel();
 789   if (gesture_provider_.OnTouchEvent(*cancel_event).succeeded) {
 790     bool causes_scrolling = false;
 791     host_->ForwardTouchEventWithLatencyInfo(
 792         ui::CreateWebTouchEventFromMotionEvent(*cancel_event, causes_scrolling),
 793         ui::LatencyInfo());
 794   }
 795 }
 796
 797 void RenderWidgetHostViewAndroid::OnDidNavigateMainFrameToNewPage() {
 798   ResetGestureDetection();
 799 }
 800
 801 void RenderWidgetHostViewAndroid::SetDoubleTapSupportEnabled(bool enabled) {
 802   gesture_provider_.SetDoubleTapSupportForPlatformEnabled(enabled);
 803 }
 804
 805 void RenderWidgetHostViewAndroid::SetMultiTouchZoomSupportEnabled(
 806     bool enabled) {
 807   gesture_provider_.SetMultiTouchZoomSupportEnabled(enabled);
 808 }
 809
 810 void RenderWidgetHostViewAndroid::ImeCancelComposition() {
 811   ime_adapter_android_.CancelComposition();
 812 }
 813
 814 void RenderWidgetHostViewAndroid::ImeCompositionRangeChanged(
 815     const gfx::Range& range,
 816     const std::vector<gfx::Rect>& character_bounds) {
 817   // TODO(yukawa): Implement this.
 818 }
 819
 820 void RenderWidgetHostViewAndroid::FocusedNodeChanged(bool is_editable_node) {
 821   ime_adapter_android_.FocusedNodeChanged(is_editable_node);
 822 }
 823
 824 void RenderWidgetHostViewAndroid::RenderProcessGone(
 825     base::TerminationStatus status, int error_code) {
 826   Destroy();
 827 }
 828
 829 void RenderWidgetHostViewAndroid::Destroy() {
 830   RemoveLayers();
 831   SetContentViewCore(NULL);
 832
 833   if (!surface_id_.is_null()) {
 834     DCHECK(surface_factory_.get());
 835     surface_factory_->Destroy(surface_id_);
 836     surface_id_ = cc::SurfaceId();
 837   }
 838   surface_factory_.reset();
 839
 840   // The RenderWidgetHost's destruction led here, so don't call it.
 841   host_ = NULL;
 842
 843   delete this;
 844 }
 845
 846 void RenderWidgetHostViewAndroid::SetTooltipText(
 847     const base::string16& tooltip_text) {
 848   // Tooltips don't makes sense on Android.
 849 }
 850
 851 void RenderWidgetHostViewAndroid::SelectionChanged(const base::string16& text,
 852                                                    size_t offset,
 853                                                    const gfx::Range& range) {
 854   RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 855
 856   if (!content_view_core_)
 857     return;
 858   if (range.is_empty()) {
 859     content_view_core_->OnSelectionChanged("");
 860     return;
 861   }
 862
 863   DCHECK(!text.empty());
 864   size_t pos = range.GetMin() - offset;
 865   size_t n = range.length();
 866
 867   DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
 868   if (pos >= text.length()) {
 869     NOTREACHED() << "The text can not cover range.";
 870     return;
 871   }
 872
 873   std::string utf8_selection = base::UTF16ToUTF8(text.substr(pos, n));
 874
 875   content_view_core_->OnSelectionChanged(utf8_selection);
 876 }
 877
 878 void RenderWidgetHostViewAndroid::SelectionBoundsChanged(
 879     const ViewHostMsg_SelectionBounds_Params& params) {
 880   NOTREACHED() << "Selection bounds should be routed through the compositor.";
 881 }
 882
 883 void RenderWidgetHostViewAndroid::SetBackgroundColor(SkColor color) {
 884   RenderWidgetHostViewBase::SetBackgroundColor(color);
 885   host_->SetBackgroundOpaque(GetBackgroundOpaque());
 886   OnDidChangeBodyBackgroundColor(color);
 887 }
 888
 889 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
 890     const gfx::Rect& src_subrect,
 891     const gfx::Size& dst_size,
 892     ReadbackRequestCallback& callback,
 893     const SkColorType preferred_color_type) {
 894   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurface");
 895   if (!host_ || host_->is_hidden()) {
 896     callback.Run(SkBitmap(), READBACK_SURFACE_UNAVAILABLE);
 897     return;
 898   }
 899   base::TimeTicks start_time = base::TimeTicks::Now();
 900   if (using_browser_compositor_ && !IsSurfaceAvailableForCopy()) {
 901     callback.Run(SkBitmap(), READBACK_SURFACE_UNAVAILABLE);
 902     return;
 903   }
 904   const gfx::Display& display =
 905       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
 906   float device_scale_factor = display.device_scale_factor();
 907   gfx::Size dst_size_in_pixel =
 908       gfx::ConvertRectToPixel(device_scale_factor, gfx::Rect(dst_size)).size();
 909   gfx::Rect src_subrect_in_pixel =
 910       gfx::ConvertRectToPixel(device_scale_factor, src_subrect);
 911
 912   if (!using_browser_compositor_) {
 913     SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback,
 914                             preferred_color_type);
 915     UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
 916                         base::TimeTicks::Now() - start_time);
 917     return;
 918   }
 919
 920   scoped_ptr<cc::CopyOutputRequest> request;
 921   scoped_refptr<cc::Layer> readback_layer;
 922   DCHECK(content_view_core_window_android_);
 923   ui::WindowAndroidCompositor* compositor =
 924       content_view_core_window_android_->GetCompositor();
 925   DCHECK(compositor);
 926   DCHECK(frame_provider_.get() || !surface_id_.is_null());
 927   scoped_refptr<cc::Layer> layer = CreateDelegatedLayer();
 928   DCHECK(layer);
 929   layer->SetHideLayerAndSubtree(true);
 930   compositor->AttachLayerForReadback(layer);
 931
 932   readback_layer = layer;
 933   request = cc::CopyOutputRequest::CreateRequest(
 934       base::Bind(&RenderWidgetHostViewAndroid::
 935                      PrepareTextureCopyOutputResultForDelegatedReadback,
 936                  dst_size_in_pixel, preferred_color_type, start_time,
 937                  readback_layer, callback));
 938   if (!src_subrect_in_pixel.IsEmpty())
 939     request->set_area(src_subrect_in_pixel);
 940   readback_layer->RequestCopyOfOutput(request.Pass());
 941 }
 942
 943 void RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceToVideoFrame(
 944       const gfx::Rect& src_subrect,
 945       const scoped_refptr<media::VideoFrame>& target,
 946       const base::Callback<void(bool)>& callback) {
 947   NOTIMPLEMENTED();
 948   callback.Run(false);
 949 }
 950
 951 bool RenderWidgetHostViewAndroid::CanCopyToVideoFrame() const {
 952   return false;
 953 }
 954
 955 void RenderWidgetHostViewAndroid::ShowDisambiguationPopup(
 956     const gfx::Rect& rect_pixels, const SkBitmap& zoomed_bitmap) {
 957   if (!content_view_core_)
 958     return;
 959
 960   content_view_core_->ShowDisambiguationPopup(rect_pixels, zoomed_bitmap);
 961 }
 962
 963 scoped_ptr<SyntheticGestureTarget>
 964 RenderWidgetHostViewAndroid::CreateSyntheticGestureTarget() {
 965   return scoped_ptr<SyntheticGestureTarget>(new SyntheticGestureTargetAndroid(
 966       host_, content_view_core_->CreateMotionEventSynthesizer()));
 967 }
 968
 969 void RenderWidgetHostViewAndroid::SendDelegatedFrameAck(
 970     uint32 output_surface_id) {
 971   DCHECK(host_);
 972   cc::CompositorFrameAck ack;
 973   if (!surface_returned_resources_.empty())
 974     ack.resources.swap(surface_returned_resources_);
 975   if (resource_collection_.get())
 976     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 977   host_->Send(new ViewMsg_SwapCompositorFrameAck(host_->GetRoutingID(),
 978                                                  output_surface_id, ack));
 979 }
 980
 981 void RenderWidgetHostViewAndroid::SendReturnedDelegatedResources(
 982     uint32 output_surface_id) {
 983   DCHECK(host_);
 984   cc::CompositorFrameAck ack;
 985   if (!surface_returned_resources_.empty()) {
 986     ack.resources.swap(surface_returned_resources_);
 987   } else {
 988     DCHECK(resource_collection_.get());
 989     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 990   }
 991
 992   host_->Send(new ViewMsg_ReclaimCompositorResources(host_->GetRoutingID(),
 993                                                      output_surface_id, ack));
 994 }
 995
 996 void RenderWidgetHostViewAndroid::UnusedResourcesAreAvailable() {
 997   DCHECK(surface_id_.is_null());
 998   if (ack_callbacks_.size())
 999     return;
1000   SendReturnedDelegatedResources(last_output_surface_id_);
1001 }
1002
1003 void RenderWidgetHostViewAndroid::ReturnResources(
1004     const cc::ReturnedResourceArray& resources) {
1005   if (resources.empty())
1006     return;
1007   std::copy(resources.begin(), resources.end(),
1008             std::back_inserter(surface_returned_resources_));
1009   if (!ack_callbacks_.size())
1010     SendReturnedDelegatedResources(last_output_surface_id_);
1011 }
1012
1013 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
1014   RemoveLayers();
1015   frame_provider_ = NULL;
1016   if (!surface_id_.is_null()) {
1017     DCHECK(surface_factory_.get());
1018     surface_factory_->Destroy(surface_id_);
1019     surface_id_ = cc::SurfaceId();
1020   }
1021   layer_ = NULL;
1022 }
1023
1024 void RenderWidgetHostViewAndroid::CheckOutputSurfaceChanged(
1025     uint32 output_surface_id) {
1026   if (output_surface_id == last_output_surface_id_)
1027     return;
1028   // Drop the cc::DelegatedFrameResourceCollection so that we will not return
1029   // any resources from the old output surface with the new output surface id.
1030   if (resource_collection_.get()) {
1031     resource_collection_->SetClient(NULL);
1032     if (resource_collection_->LoseAllResources())
1033       SendReturnedDelegatedResources(last_output_surface_id_);
1034     resource_collection_ = NULL;
1035   }
1036   DestroyDelegatedContent();
1037   surface_factory_.reset();
1038   if (!surface_returned_resources_.empty())
1039     SendReturnedDelegatedResources(last_output_surface_id_);
1040
1041   last_output_surface_id_ = output_surface_id;
1042 }
1043
1044 void RenderWidgetHostViewAndroid::SubmitFrame(
1045     scoped_ptr<cc::CompositorFrame> frame) {
1046   cc::SurfaceManager* manager = CompositorImpl::GetSurfaceManager();
1047   if (manager) {
1048     if (!surface_factory_) {
1049       surface_factory_ = make_scoped_ptr(new cc::SurfaceFactory(manager, this));
1050     }
1051     if (surface_id_.is_null() ||
1052         texture_size_in_layer_ != current_surface_size_) {
1053       RemoveLayers();
1054       if (!surface_id_.is_null())
1055         surface_factory_->Destroy(surface_id_);
1056       surface_id_ = id_allocator_->GenerateId();
1057       surface_factory_->Create(surface_id_);
1058       layer_ = CreateDelegatedLayer();
1059
1060       DCHECK(layer_);
1061
1062       current_surface_size_ = texture_size_in_layer_;
1063       AttachLayers();
1064     }
1065
1066     cc::SurfaceFactory::DrawCallback ack_callback =
1067         base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks,
1068                    weak_ptr_factory_.GetWeakPtr());
1069     surface_factory_->SubmitFrame(surface_id_, frame.Pass(), ack_callback);
1070   } else {
1071     if (!resource_collection_.get()) {
1072       resource_collection_ = new cc::DelegatedFrameResourceCollection;
1073       resource_collection_->SetClient(this);
1074     }
1075     if (!frame_provider_.get() ||
1076         texture_size_in_layer_ != frame_provider_->frame_size()) {
1077       RemoveLayers();
1078       frame_provider_ = new cc::DelegatedFrameProvider(
1079           resource_collection_.get(), frame->delegated_frame_data.Pass());
1080       layer_ = cc::DelegatedRendererLayer::Create(Compositor::LayerSettings(),
1081                                                   frame_provider_);
1082       AttachLayers();
1083     } else {
1084       frame_provider_->SetFrameData(frame->delegated_frame_data.Pass());
1085     }
1086   }
1087 }
1088
1089 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
1090     uint32 output_surface_id,
1091     scoped_ptr<cc::CompositorFrame> frame) {
1092   CheckOutputSurfaceChanged(output_surface_id);
1093   bool has_content = !texture_size_in_layer_.IsEmpty();
1094
1095   // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the
1096   // renderer frame, assuming that the browser compositor will scale
1097   // it back up to device scale.  But on Android we put our browser layers in
1098   // physical pixels and set our browser CC device_scale_factor to 1, so this
1099   // suppresses the transform.  This line may need to be removed when fixing
1100   // http://crbug.com/384134 or http://crbug.com/310763
1101   frame->delegated_frame_data->device_scale_factor = 1.0f;
1102
1103   if (!has_content) {
1104     DestroyDelegatedContent();
1105   } else {
1106     SubmitFrame(frame.Pass());
1107   }
1108
1109   if (layer_.get()) {
1110     layer_->SetIsDrawable(true);
1111     layer_->SetContentsOpaque(true);
1112     layer_->SetBounds(content_size_in_layer_);
1113   }
1114
1115   base::Closure ack_callback =
1116       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
1117                  weak_ptr_factory_.GetWeakPtr(),
1118                  output_surface_id);
1119
1120   ack_callbacks_.push(ack_callback);
1121   if (host_->is_hidden())
1122     RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
1123 }
1124
1125 void RenderWidgetHostViewAndroid::ComputeContentsSize(
1126     const cc::CompositorFrameMetadata& frame_metadata) {
1127   // Calculate the content size.  This should be 0 if the texture_size is 0.
1128   gfx::Vector2dF offset;
1129   if (texture_size_in_layer_.IsEmpty())
1130     content_size_in_layer_ = gfx::Size();
1131   content_size_in_layer_ = gfx::ToCeiledSize(gfx::ScaleSize(
1132       frame_metadata.scrollable_viewport_size,
1133       frame_metadata.device_scale_factor * frame_metadata.page_scale_factor));
1134
1135 }
1136
1137 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
1138     uint32 output_surface_id,
1139     scoped_ptr<cc::CompositorFrame> frame) {
1140   last_scroll_offset_ = frame->metadata.root_scroll_offset;
1141   if (!frame->delegated_frame_data) {
1142     LOG(ERROR) << "Non-delegated renderer path no longer supported";
1143     return;
1144   }
1145
1146   if (locks_on_frame_count_ > 0) {
1147     DCHECK(HasValidFrame());
1148     RetainFrame(output_surface_id, frame.Pass());
1149     return;
1150   }
1151
1152   if (!CompositorImpl::GetSurfaceManager() && layer_.get() &&
1153       layer_->layer_tree_host()) {
1154     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
1155       scoped_ptr<cc::SwapPromise> swap_promise(
1156           new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
1157       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
1158     }
1159   }
1160
1161   DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
1162
1163   cc::RenderPass* root_pass =
1164       frame->delegated_frame_data->render_pass_list.back();
1165   texture_size_in_layer_ = root_pass->output_rect.size();
1166   ComputeContentsSize(frame->metadata);
1167
1168   cc::CompositorFrameMetadata metadata = frame->metadata;
1169
1170   SwapDelegatedFrame(output_surface_id, frame.Pass());
1171   frame_evictor_->SwappedFrame(!host_->is_hidden());
1172
1173   // As the metadata update may trigger view invalidation, always call it after
1174   // any potential compositor scheduling.
1175   OnFrameMetadataUpdated(metadata);
1176 }
1177
1178 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
1179     uint32 output_surface_id,
1180     scoped_ptr<cc::CompositorFrame> frame) {
1181   InternalSwapCompositorFrame(output_surface_id, frame.Pass());
1182 }
1183
1184 void RenderWidgetHostViewAndroid::RetainFrame(
1185     uint32 output_surface_id,
1186     scoped_ptr<cc::CompositorFrame> frame) {
1187   DCHECK(locks_on_frame_count_);
1188
1189   // Store the incoming frame so that it can be swapped when all the locks have
1190   // been released. If there is already a stored frame, then replace and skip
1191   // the previous one but make sure we still eventually send the ACK. Holding
1192   // the ACK also blocks the renderer when its max_frames_pending is reached.
1193   if (last_frame_info_) {
1194     base::Closure ack_callback =
1195         base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
1196                    weak_ptr_factory_.GetWeakPtr(),
1197                    last_frame_info_->output_surface_id);
1198
1199     ack_callbacks_.push(ack_callback);
1200   }
1201
1202   last_frame_info_.reset(new LastFrameInfo(output_surface_id, frame.Pass()));
1203 }
1204
1205 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
1206     const cc::CompositorFrameMetadata& frame_metadata) {
1207   if (!content_view_core_)
1208     return;
1209
1210   // This is a subset of OnSwapCompositorFrame() used in the synchronous
1211   // compositor flow.
1212   OnFrameMetadataUpdated(frame_metadata);
1213   ComputeContentsSize(frame_metadata);
1214
1215   // DevTools ScreenCast support for Android WebView.
1216   WebContents* web_contents = content_view_core_->GetWebContents();
1217   if (DevToolsAgentHost::HasFor(web_contents)) {
1218     scoped_refptr<DevToolsAgentHost> dtah =
1219         DevToolsAgentHost::GetOrCreateFor(web_contents);
1220     // Unblock the compositor.
1221     BrowserThread::PostTask(
1222         BrowserThread::UI, FROM_HERE,
1223         base::Bind(
1224             &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame,
1225             static_cast<RenderFrameDevToolsAgentHost*>(dtah.get()),
1226             frame_metadata));
1227   }
1228 }
1229
1230 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
1231   if (layer_.get())
1232     layer_->SetContentsOpaque(!enabled);
1233 }
1234
1235 bool RenderWidgetHostViewAndroid::SupportsAnimation() const {
1236   // The synchronous (WebView) compositor does not have a proper browser
1237   // compositor with which to drive animations.
1238   return using_browser_compositor_;
1239 }
1240
1241 void RenderWidgetHostViewAndroid::SetNeedsAnimate() {
1242   DCHECK(content_view_core_window_android_);
1243   DCHECK(using_browser_compositor_);
1244   content_view_core_window_android_->SetNeedsAnimate();
1245 }
1246
1247 void RenderWidgetHostViewAndroid::MoveCaret(const gfx::PointF& position) {
1248   MoveCaret(gfx::Point(position.x(), position.y()));
1249 }
1250
1251 void RenderWidgetHostViewAndroid::MoveRangeSelectionExtent(
1252     const gfx::PointF& extent) {
1253   DCHECK(content_view_core_);
1254   content_view_core_->MoveRangeSelectionExtent(extent);
1255 }
1256
1257 void RenderWidgetHostViewAndroid::SelectBetweenCoordinates(
1258     const gfx::PointF& base,
1259     const gfx::PointF& extent) {
1260   DCHECK(content_view_core_);
1261   content_view_core_->SelectBetweenCoordinates(base, extent);
1262 }
1263
1264 void RenderWidgetHostViewAndroid::OnSelectionEvent(
1265     ui::SelectionEventType event) {
1266   DCHECK(content_view_core_);
1267   DCHECK(selection_controller_);
1268   // If a selection drag has started, it has taken over the active touch
1269   // sequence. Immediately cancel gesture detection and any downstream touch
1270   // listeners (e.g., web content) to communicate this transfer.
1271   if (event == ui::SELECTION_HANDLES_SHOWN)
1272     ResetGestureDetection();
1273   content_view_core_->OnSelectionEvent(
1274       event, selection_controller_->GetStartPosition(),
1275       GetSelectionRect(*selection_controller_));
1276 }
1277
1278 scoped_ptr<ui::TouchHandleDrawable>
1279 RenderWidgetHostViewAndroid::CreateDrawable() {
1280   DCHECK(content_view_core_);
1281   if (!using_browser_compositor_)
1282     return content_view_core_->CreatePopupTouchHandleDrawable();
1283
1284   return scoped_ptr<ui::TouchHandleDrawable>(new CompositedTouchHandleDrawable(
1285       content_view_core_->GetLayer().get(),
1286       content_view_core_->GetDpiScale(),
1287       // Use the activity context (instead of the application context) to ensure
1288       // proper handle theming.
1289       content_view_core_->GetContext().obj()));
1290 }
1291
1292 void RenderWidgetHostViewAndroid::SynchronousCopyContents(
1293     const gfx::Rect& src_subrect_in_pixel,
1294     const gfx::Size& dst_size_in_pixel,
1295     ReadbackRequestCallback& callback,
1296     const SkColorType color_type) {
1297   gfx::Size input_size_in_pixel;
1298   if (src_subrect_in_pixel.IsEmpty())
1299     input_size_in_pixel = content_size_in_layer_;
1300   else
1301     input_size_in_pixel = src_subrect_in_pixel.size();
1302
1303   gfx::Size output_size_in_pixel;
1304   if (dst_size_in_pixel.IsEmpty())
1305     output_size_in_pixel = input_size_in_pixel;
1306   else
1307     output_size_in_pixel = dst_size_in_pixel;
1308   int output_width = output_size_in_pixel.width();
1309   int output_height = output_size_in_pixel.height();
1310
1311   SynchronousCompositor* compositor =
1312       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
1313                                         host_->GetRoutingID());
1314   if (!compositor) {
1315     callback.Run(SkBitmap(), READBACK_FAILED);
1316     return;
1317   }
1318
1319   SkBitmap bitmap;
1320   bitmap.allocPixels(SkImageInfo::Make(output_width,
1321                                        output_height,
1322                                        color_type,
1323                                        kPremul_SkAlphaType));
1324   SkCanvas canvas(bitmap);
1325   canvas.scale(
1326       (float)output_width / (float)input_size_in_pixel.width(),
1327       (float)output_height / (float)input_size_in_pixel.height());
1328   compositor->DemandDrawSw(&canvas);
1329   callback.Run(bitmap, READBACK_SUCCESS);
1330 }
1331
1332 void RenderWidgetHostViewAndroid::OnFrameMetadataUpdated(
1333     const cc::CompositorFrameMetadata& frame_metadata) {
1334   bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
1335   gesture_provider_.SetDoubleTapSupportForPageEnabled(!is_mobile_optimized);
1336
1337   if (!content_view_core_)
1338     return;
1339
1340   if (overscroll_controller_)
1341     overscroll_controller_->OnFrameMetadataUpdated(frame_metadata);
1342
1343   if (selection_controller_) {
1344     selection_controller_->OnSelectionEditable(
1345         frame_metadata.selection.is_editable);
1346     selection_controller_->OnSelectionEmpty(
1347         frame_metadata.selection.is_empty_text_form_control);
1348     selection_controller_->OnSelectionBoundsChanged(
1349         ConvertSelectionBound(frame_metadata.selection.start),
1350         ConvertSelectionBound(frame_metadata.selection.end));
1351   }
1352
1353   // All offsets and sizes are in CSS pixels.
1354   content_view_core_->UpdateFrameInfo(
1355       frame_metadata.root_scroll_offset,
1356       frame_metadata.page_scale_factor,
1357       gfx::Vector2dF(frame_metadata.min_page_scale_factor,
1358                      frame_metadata.max_page_scale_factor),
1359       frame_metadata.root_layer_size,
1360       frame_metadata.scrollable_viewport_size,
1361       frame_metadata.location_bar_offset,
1362       frame_metadata.location_bar_content_translation,
1363       is_mobile_optimized);
1364 #if defined(VIDEO_HOLE)
1365   if (host_ && host_->IsRenderView()) {
1366     RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(
1367         RenderViewHost::From(host_));
1368     WebContentsImpl* web_contents_impl =
1369         static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvhi));
1370     if (web_contents_impl)
1371       web_contents_impl->media_web_contents_observer()->OnFrameInfoUpdated();
1372   }
1373 #endif  // defined(VIDEO_HOLE)
1374 }
1375
1376 void RenderWidgetHostViewAndroid::AcceleratedSurfaceInitialized(int route_id) {
1377   // TODO: remove need for the surface id here
1378   accelerated_surface_route_id_ = route_id;
1379 }
1380
1381 void RenderWidgetHostViewAndroid::ShowInternal() {
1382   DCHECK(is_showing_);
1383   if (!host_ || !host_->is_hidden())
1384     return;
1385
1386   if (layer_.get())
1387     layer_->SetHideLayerAndSubtree(false);
1388
1389   frame_evictor_->SetVisible(true);
1390
1391   if (overscroll_controller_)
1392     overscroll_controller_->Enable();
1393
1394   host_->WasShown(ui::LatencyInfo());
1395
1396   if (content_view_core_) {
1397     StartObservingRootWindow();
1398     RequestVSyncUpdate(BEGIN_FRAME);
1399   }
1400 }
1401
1402 void RenderWidgetHostViewAndroid::HideInternal(
1403     bool hide_frontbuffer,
1404     bool stop_observing_root_window) {
1405   if (hide_frontbuffer) {
1406     if (layer_.get() && locks_on_frame_count_ == 0)
1407       layer_->SetHideLayerAndSubtree(true);
1408
1409     frame_evictor_->SetVisible(false);
1410   }
1411
1412   if (stop_observing_root_window)
1413     StopObservingRootWindow();
1414
1415   if (!host_ || host_->is_hidden())
1416     return;
1417
1418   if (overscroll_controller_)
1419     overscroll_controller_->Disable();
1420
1421   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
1422
1423   // Inform the renderer that we are being hidden so it can reduce its resource
1424   // utilization.
1425   host_->WasHidden();
1426 }
1427
1428 void RenderWidgetHostViewAndroid::AttachLayers() {
1429   if (!content_view_core_)
1430     return;
1431   if (!layer_.get())
1432     return;
1433
1434   content_view_core_->AttachLayer(layer_);
1435   if (overscroll_controller_)
1436     overscroll_controller_->Enable();
1437   layer_->SetHideLayerAndSubtree(!is_showing_);
1438 }
1439
1440 void RenderWidgetHostViewAndroid::RemoveLayers() {
1441   if (!content_view_core_)
1442     return;
1443
1444   if (!layer_.get())
1445     return;
1446
1447   content_view_core_->RemoveLayer(layer_);
1448   if (overscroll_controller_)
1449     overscroll_controller_->Disable();
1450 }
1451
1452 void RenderWidgetHostViewAndroid::RequestVSyncUpdate(uint32 requests) {
1453   bool should_request_vsync = !outstanding_vsync_requests_ && requests;
1454   outstanding_vsync_requests_ |= requests;
1455
1456   // If the host has been hidden, defer vsync requests until it is shown
1457   // again via |Show()|.
1458   if (!host_ || host_->is_hidden())
1459     return;
1460
1461   // Note that if we're not currently observing the root window, outstanding
1462   // vsync requests will be pushed if/when we resume observing in
1463   // |StartObservingRootWindow()|.
1464   if (observing_root_window_ && should_request_vsync)
1465     content_view_core_window_android_->RequestVSyncUpdate();
1466 }
1467
1468 void RenderWidgetHostViewAndroid::StartObservingRootWindow() {
1469   DCHECK(content_view_core_window_android_);
1470   DCHECK(is_showing_);
1471   if (observing_root_window_)
1472     return;
1473
1474   observing_root_window_ = true;
1475   content_view_core_window_android_->AddObserver(this);
1476
1477   // Clear existing vsync requests to allow a request to the new window.
1478   uint32 outstanding_vsync_requests = outstanding_vsync_requests_;
1479   outstanding_vsync_requests_ = 0;
1480   RequestVSyncUpdate(outstanding_vsync_requests);
1481 }
1482
1483 void RenderWidgetHostViewAndroid::StopObservingRootWindow() {
1484   if (!content_view_core_window_android_) {
1485     DCHECK(!observing_root_window_);
1486     return;
1487   }
1488
1489   if (!observing_root_window_)
1490     return;
1491
1492   observing_root_window_ = false;
1493   content_view_core_window_android_->RemoveObserver(this);
1494 }
1495
1496 void RenderWidgetHostViewAndroid::SendBeginFrame(base::TimeTicks frame_time,
1497                                                  base::TimeDelta vsync_period) {
1498   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::SendBeginFrame",
1499                "frame_time_us", frame_time.ToInternalValue());
1500
1501   if (using_browser_compositor_) {
1502     // TODO(brianderson): Replace this hardcoded deadline after Android
1503     // switches to Surfaces and the Browser's commit isn't in the critcal path.
1504     base::TimeTicks deadline = frame_time + (vsync_period * 0.6);
1505
1506     host_->Send(new ViewMsg_BeginFrame(
1507         host_->GetRoutingID(),
1508         cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
1509                                    vsync_period, cc::BeginFrameArgs::NORMAL)));
1510   } else {
1511     SynchronousCompositorImpl* compositor = SynchronousCompositorImpl::FromID(
1512         host_->GetProcess()->GetID(), host_->GetRoutingID());
1513     if (compositor) {
1514       // The synchronous compositor synchronously does it's work in this call.
1515       // It does not use a deadline.
1516       compositor->BeginFrame(cc::BeginFrameArgs::Create(
1517           BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks(), vsync_period,
1518           cc::BeginFrameArgs::NORMAL));
1519     }
1520   }
1521 }
1522
1523 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
1524   bool needs_animate = false;
1525   if (overscroll_controller_) {
1526     needs_animate |= overscroll_controller_->Animate(
1527         frame_time, content_view_core_->GetLayer().get());
1528   }
1529   if (selection_controller_)
1530     needs_animate |= selection_controller_->Animate(frame_time);
1531   return needs_animate;
1532 }
1533
1534 void RenderWidgetHostViewAndroid::RequestDisallowInterceptTouchEvent() {
1535   if (content_view_core_)
1536     content_view_core_->RequestDisallowInterceptTouchEvent();
1537 }
1538
1539 void RenderWidgetHostViewAndroid::EvictDelegatedFrame() {
1540   if (layer_.get())
1541     DestroyDelegatedContent();
1542   frame_evictor_->DiscardedFrame();
1543 }
1544
1545 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
1546     const gfx::Size& desired_size) {
1547   NOTREACHED();
1548   return false;
1549 }
1550
1551 void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* result) {
1552   // ScreenInfo isn't tied to the widget on Android. Always return the default.
1553   RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
1554 }
1555
1556 // TODO(jrg): Find out the implications and answer correctly here,
1557 // as we are returning the WebView and not root window bounds.
1558 gfx::Rect RenderWidgetHostViewAndroid::GetBoundsInRootWindow() {
1559   return GetViewBounds();
1560 }
1561
1562 gfx::GLSurfaceHandle RenderWidgetHostViewAndroid::GetCompositingSurface() {
1563   gfx::GLSurfaceHandle handle =
1564       gfx::GLSurfaceHandle(gfx::kNullPluginWindow, gfx::NULL_TRANSPORT);
1565   if (using_browser_compositor_) {
1566     handle.parent_client_id =
1567         BrowserGpuChannelHostFactory::instance()->GetGpuChannelId();
1568   }
1569   return handle;
1570 }
1571
1572 void RenderWidgetHostViewAndroid::ProcessAckedTouchEvent(
1573     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
1574   const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
1575   gesture_provider_.OnTouchEventAck(touch.event.uniqueTouchEventId,
1576                                     event_consumed);
1577 }
1578
1579 void RenderWidgetHostViewAndroid::GestureEventAck(
1580     const blink::WebGestureEvent& event,
1581     InputEventAckState ack_result) {
1582   if (overscroll_controller_)
1583     overscroll_controller_->OnGestureEventAck(event, ack_result);
1584
1585   if (content_view_core_)
1586     content_view_core_->OnGestureEventAck(event, ack_result);
1587 }
1588
1589 InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
1590     const blink::WebInputEvent& input_event) {
1591   if (selection_controller_ &&
1592       blink::WebInputEvent::isGestureEventType(input_event.type)) {
1593     const blink::WebGestureEvent& gesture_event =
1594         static_cast<const blink::WebGestureEvent&>(input_event);
1595     switch (gesture_event.type) {
1596       case blink::WebInputEvent::GestureLongPress:
1597         if (selection_controller_->WillHandleLongPressEvent(
1598                 base::TimeTicks() +
1599                     base::TimeDelta::FromSecondsD(input_event.timeStampSeconds),
1600                 gfx::PointF(gesture_event.x, gesture_event.y))) {
1601           return INPUT_EVENT_ACK_STATE_CONSUMED;
1602         }
1603         break;
1604
1605       case blink::WebInputEvent::GestureTap:
1606         if (selection_controller_->WillHandleTapEvent(
1607                 gfx::PointF(gesture_event.x, gesture_event.y))) {
1608           return INPUT_EVENT_ACK_STATE_CONSUMED;
1609         }
1610         break;
1611
1612       default:
1613         break;
1614     }
1615   }
1616
1617   if (overscroll_controller_ &&
1618       blink::WebInputEvent::isGestureEventType(input_event.type) &&
1619       overscroll_controller_->WillHandleGestureEvent(
1620           static_cast<const blink::WebGestureEvent&>(input_event))) {
1621     return INPUT_EVENT_ACK_STATE_CONSUMED;
1622   }
1623
1624   if (content_view_core_ && content_view_core_->FilterInputEvent(input_event))
1625     return INPUT_EVENT_ACK_STATE_CONSUMED;
1626
1627   if (!host_)
1628     return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1629
1630   if (input_event.type == blink::WebInputEvent::GestureTapDown ||
1631       input_event.type == blink::WebInputEvent::TouchStart) {
1632     GpuDataManagerImpl* gpu_data = GpuDataManagerImpl::GetInstance();
1633     GpuProcessHostUIShim* shim = GpuProcessHostUIShim::GetOneInstance();
1634     if (shim && gpu_data && accelerated_surface_route_id_ &&
1635         gpu_data->IsDriverBugWorkaroundActive(gpu::WAKE_UP_GPU_BEFORE_DRAWING))
1636       shim->Send(
1637           new AcceleratedSurfaceMsg_WakeUpGpu(accelerated_surface_route_id_));
1638   }
1639
1640   SynchronousCompositorImpl* compositor =
1641       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
1642                                           host_->GetRoutingID());
1643   if (compositor)
1644     return compositor->HandleInputEvent(input_event);
1645   return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1646 }
1647
1648 void RenderWidgetHostViewAndroid::OnSetNeedsFlushInput() {
1649   TRACE_EVENT0("input", "RenderWidgetHostViewAndroid::OnSetNeedsFlushInput");
1650   RequestVSyncUpdate(FLUSH_INPUT);
1651 }
1652
1653 BrowserAccessibilityManager*
1654     RenderWidgetHostViewAndroid::CreateBrowserAccessibilityManager(
1655         BrowserAccessibilityDelegate* delegate) {
1656   // TODO(dmazzoni): Currently there can only be one
1657   // BrowserAccessibilityManager per ContentViewCore, so return NULL
1658   // if there's already a BrowserAccessibilityManager for the main
1659   // frame.  Eventually, in order to support cross-process iframes on
1660   // Android we'll need to add support for a
1661   // BrowserAccessibilityManager for a child frame.
1662   // http://crbug.com/423846
1663   if (!host_ || host_->GetRootBrowserAccessibilityManager())
1664     return NULL;
1665
1666   base::android::ScopedJavaLocalRef<jobject> obj;
1667   if (content_view_core_)
1668     obj = content_view_core_->GetJavaObject();
1669   return new BrowserAccessibilityManagerAndroid(
1670       obj,
1671       BrowserAccessibilityManagerAndroid::GetEmptyDocument(),
1672       delegate);
1673 }
1674
1675 bool RenderWidgetHostViewAndroid::LockMouse() {
1676   NOTIMPLEMENTED();
1677   return false;
1678 }
1679
1680 void RenderWidgetHostViewAndroid::UnlockMouse() {
1681   NOTIMPLEMENTED();
1682 }
1683
1684 // Methods called from the host to the render
1685
1686 void RenderWidgetHostViewAndroid::SendKeyEvent(
1687     const NativeWebKeyboardEvent& event) {
1688   if (host_)
1689     host_->ForwardKeyboardEvent(event);
1690 }
1691
1692 void RenderWidgetHostViewAndroid::SendMouseEvent(
1693     const blink::WebMouseEvent& event) {
1694   if (host_)
1695     host_->ForwardMouseEvent(event);
1696 }
1697
1698 void RenderWidgetHostViewAndroid::SendMouseWheelEvent(
1699     const blink::WebMouseWheelEvent& event) {
1700   if (host_)
1701     host_->ForwardWheelEvent(event);
1702 }
1703
1704 void RenderWidgetHostViewAndroid::SendGestureEvent(
1705     const blink::WebGestureEvent& event) {
1706   // Sending a gesture that may trigger overscroll should resume the effect.
1707   if (overscroll_controller_)
1708     overscroll_controller_->Enable();
1709
1710   if (host_)
1711     host_->ForwardGestureEventWithLatencyInfo(event, ui::LatencyInfo());
1712 }
1713
1714 void RenderWidgetHostViewAndroid::MoveCaret(const gfx::Point& point) {
1715   if (host_)
1716     host_->MoveCaret(point);
1717 }
1718
1719 void RenderWidgetHostViewAndroid::DismissTextHandles() {
1720   if (selection_controller_)
1721     selection_controller_->HideAndDisallowShowingAutomatically();
1722 }
1723
1724 void RenderWidgetHostViewAndroid::SetTextHandlesTemporarilyHidden(bool hidden) {
1725   if (selection_controller_)
1726     selection_controller_->SetTemporarilyHidden(hidden);
1727 }
1728
1729 void RenderWidgetHostViewAndroid::OnShowingPastePopup(
1730     const gfx::PointF& point) {
1731   if (!selection_controller_)
1732     return;
1733
1734   // As the paste popup may be triggered *before* the bounds and editability
1735   // of the region have been updated, explicitly set the properties now.
1736   // TODO(jdduke): Remove this workaround when auxiliary paste popup
1737   // notifications are no longer required, crbug.com/398170.
1738   ui::SelectionBound insertion_bound;
1739   insertion_bound.set_type(ui::SelectionBound::CENTER);
1740   insertion_bound.set_visible(true);
1741   insertion_bound.SetEdge(point, point);
1742   selection_controller_->HideAndDisallowShowingAutomatically();
1743   selection_controller_->OnSelectionEditable(true);
1744   selection_controller_->OnSelectionEmpty(true);
1745   selection_controller_->OnSelectionBoundsChanged(insertion_bound,
1746                                                   insertion_bound);
1747   selection_controller_->AllowShowingFromCurrentSelection();
1748 }
1749
1750 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
1751   return cached_background_color_;
1752 }
1753
1754 void RenderWidgetHostViewAndroid::DidOverscroll(
1755     const DidOverscrollParams& params) {
1756   if (!content_view_core_ || !layer_.get() || !is_showing_)
1757     return;
1758
1759   if (overscroll_controller_)
1760     overscroll_controller_->OnOverscrolled(params);
1761 }
1762
1763 void RenderWidgetHostViewAndroid::DidStopFlinging() {
1764   if (content_view_core_)
1765     content_view_core_->DidStopFlinging();
1766 }
1767
1768 uint32_t RenderWidgetHostViewAndroid::GetSurfaceIdNamespace() {
1769   if (id_allocator_)
1770     return id_allocator_->id_namespace();
1771   return 0;
1772 }
1773
1774 void RenderWidgetHostViewAndroid::SetContentViewCore(
1775     ContentViewCoreImpl* content_view_core) {
1776   RemoveLayers();
1777   StopObservingRootWindow();
1778
1779   bool resize = false;
1780   if (content_view_core != content_view_core_) {
1781     overscroll_controller_.reset();
1782     selection_controller_.reset();
1783     ReleaseLocksOnSurface();
1784     resize = true;
1785   }
1786
1787   content_view_core_ = content_view_core;
1788   content_view_core_window_android_ =
1789       content_view_core_ ? content_view_core_->GetWindowAndroid() : nullptr;
1790   DCHECK_EQ(!!content_view_core_, !!content_view_core_window_android_);
1791
1792   BrowserAccessibilityManager* manager = NULL;
1793   if (host_)
1794     manager = host_->GetRootBrowserAccessibilityManager();
1795   if (manager) {
1796     base::android::ScopedJavaLocalRef<jobject> obj;
1797     if (content_view_core_)
1798       obj = content_view_core_->GetJavaObject();
1799     manager->ToBrowserAccessibilityManagerAndroid()->SetContentViewCore(obj);
1800   }
1801
1802   AttachLayers();
1803
1804   if (!content_view_core_)
1805     return;
1806
1807   if (is_showing_)
1808     StartObservingRootWindow();
1809
1810   if (resize)
1811     WasResized();
1812
1813   if (!selection_controller_)
1814     selection_controller_ = CreateSelectionController(this, content_view_core_);
1815
1816   if (!overscroll_controller_ &&
1817       content_view_core_window_android_->GetCompositor()) {
1818     overscroll_controller_ = CreateOverscrollController(content_view_core_);
1819   }
1820 }
1821
1822 void RenderWidgetHostViewAndroid::RunAckCallbacks(
1823     cc::SurfaceDrawStatus status) {
1824   while (!ack_callbacks_.empty()) {
1825     ack_callbacks_.front().Run();
1826     ack_callbacks_.pop();
1827   }
1828 }
1829
1830 void RenderWidgetHostViewAndroid::OnGestureEvent(
1831     const ui::GestureEventData& gesture) {
1832   blink::WebGestureEvent web_gesture =
1833       ui::CreateWebGestureEventFromGestureEventData(gesture);
1834   // TODO(jdduke): Remove this workaround after Android fixes UiAutomator to
1835   // stop providing shift meta values to synthetic MotionEvents. This prevents
1836   // unintended shift+click interpretation of all accessibility clicks.
1837   // See crbug.com/443247.
1838   if (web_gesture.type == blink::WebInputEvent::GestureTap &&
1839       web_gesture.modifiers == blink::WebInputEvent::ShiftKey) {
1840     web_gesture.modifiers = 0;
1841   }
1842   SendGestureEvent(web_gesture);
1843 }
1844
1845 void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
1846   RunAckCallbacks(cc::SurfaceDrawStatus::DRAWN);
1847 }
1848
1849 void RenderWidgetHostViewAndroid::OnRootWindowVisibilityChanged(bool visible) {
1850   DCHECK(is_showing_);
1851   if (visible) {
1852     ShowInternal();
1853   } else {
1854     bool hide_frontbuffer = true;
1855     bool stop_observing_root_window = false;
1856     HideInternal(hide_frontbuffer, stop_observing_root_window);
1857   }
1858 }
1859
1860 void RenderWidgetHostViewAndroid::OnAttachCompositor() {
1861   DCHECK(content_view_core_);
1862   if (!overscroll_controller_)
1863     overscroll_controller_ = CreateOverscrollController(content_view_core_);
1864 }
1865
1866 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
1867   DCHECK(content_view_core_);
1868   DCHECK(using_browser_compositor_);
1869   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
1870   overscroll_controller_.reset();
1871 }
1872
1873 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
1874                                           base::TimeDelta vsync_period) {
1875   TRACE_EVENT0("cc,benchmark", "RenderWidgetHostViewAndroid::OnVSync");
1876   if (!host_ || host_->is_hidden())
1877     return;
1878
1879   if (outstanding_vsync_requests_ & FLUSH_INPUT) {
1880     outstanding_vsync_requests_ &= ~FLUSH_INPUT;
1881     host_->FlushInput();
1882   }
1883
1884   if (outstanding_vsync_requests_ & BEGIN_FRAME ||
1885       outstanding_vsync_requests_ & PERSISTENT_BEGIN_FRAME) {
1886     outstanding_vsync_requests_ &= ~BEGIN_FRAME;
1887     SendBeginFrame(frame_time, vsync_period);
1888   }
1889
1890   // This allows for SendBeginFrame and FlushInput to modify
1891   // outstanding_vsync_requests.
1892   uint32 outstanding_vsync_requests = outstanding_vsync_requests_;
1893   outstanding_vsync_requests_ = 0;
1894   RequestVSyncUpdate(outstanding_vsync_requests);
1895 }
1896
1897 void RenderWidgetHostViewAndroid::OnAnimate(base::TimeTicks begin_frame_time) {
1898   if (Animate(begin_frame_time))
1899     SetNeedsAnimate();
1900 }
1901
1902 void RenderWidgetHostViewAndroid::OnActivityStopped() {
1903   TRACE_EVENT0("browser", "RenderWidgetHostViewAndroid::OnActivityStopped");
1904   DCHECK(is_showing_);
1905   bool hide_frontbuffer = false;
1906   bool stop_observing_root_window = false;
1907   HideInternal(hide_frontbuffer, stop_observing_root_window);
1908 }
1909
1910 void RenderWidgetHostViewAndroid::OnActivityStarted() {
1911   TRACE_EVENT0("browser", "RenderWidgetHostViewAndroid::OnActivityStarted");
1912   DCHECK(is_showing_);
1913   ShowInternal();
1914 }
1915
1916 void RenderWidgetHostViewAndroid::OnLostResources() {
1917   ReleaseLocksOnSurface();
1918   if (layer_.get())
1919     DestroyDelegatedContent();
1920   DCHECK(ack_callbacks_.empty());
1921 }
1922
1923 // static
1924 void RenderWidgetHostViewAndroid::
1925     PrepareTextureCopyOutputResultForDelegatedReadback(
1926         const gfx::Size& dst_size_in_pixel,
1927         SkColorType color_type,
1928         const base::TimeTicks& start_time,
1929         scoped_refptr<cc::Layer> readback_layer,
1930         ReadbackRequestCallback& callback,
1931         scoped_ptr<cc::CopyOutputResult> result) {
1932   readback_layer->RemoveFromParent();
1933   PrepareTextureCopyOutputResult(
1934       dst_size_in_pixel, color_type, start_time, callback, result.Pass());
1935 }
1936
1937 // static
1938 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
1939     const gfx::Size& dst_size_in_pixel,
1940     SkColorType color_type,
1941     const base::TimeTicks& start_time,
1942     ReadbackRequestCallback& callback,
1943     scoped_ptr<cc::CopyOutputResult> result) {
1944   base::ScopedClosureRunner scoped_callback_runner(
1945       base::Bind(callback, SkBitmap(), READBACK_FAILED));
1946   TRACE_EVENT0("cc",
1947                "RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult");
1948
1949   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
1950     return;
1951
1952   gfx::Size output_size_in_pixel;
1953   if (dst_size_in_pixel.IsEmpty())
1954     output_size_in_pixel = result->size();
1955   else
1956     output_size_in_pixel = dst_size_in_pixel;
1957
1958   GLHelper* gl_helper = GetPostReadbackGLHelper();
1959   if (!gl_helper)
1960     return;
1961   if (!gl_helper->IsReadbackConfigSupported(color_type))
1962     color_type = kRGBA_8888_SkColorType;
1963   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
1964   if (!bitmap->tryAllocPixels(SkImageInfo::Make(output_size_in_pixel.width(),
1965                                                 output_size_in_pixel.height(),
1966                                                 color_type,
1967                                                 kOpaque_SkAlphaType))) {
1968     scoped_callback_runner.Reset(
1969         base::Bind(callback, SkBitmap(), READBACK_BITMAP_ALLOCATION_FAILURE));
1970     return;
1971   }
1972
1973
1974   scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock(
1975       new SkAutoLockPixels(*bitmap));
1976   uint8* pixels = static_cast<uint8*>(bitmap->getPixels());
1977
1978   cc::TextureMailbox texture_mailbox;
1979   scoped_ptr<cc::SingleReleaseCallback> release_callback;
1980   result->TakeTexture(&texture_mailbox, &release_callback);
1981   DCHECK(texture_mailbox.IsTexture());
1982   if (!texture_mailbox.IsTexture())
1983     return;
1984
1985   ignore_result(scoped_callback_runner.Release());
1986
1987   gl_helper->CropScaleReadbackAndCleanMailbox(
1988       texture_mailbox.mailbox(),
1989       texture_mailbox.sync_point(),
1990       result->size(),
1991       gfx::Rect(result->size()),
1992       output_size_in_pixel,
1993       pixels,
1994       color_type,
1995       base::Bind(&CopyFromCompositingSurfaceFinished,
1996                  callback,
1997                  base::Passed(&release_callback),
1998                  base::Passed(&bitmap),
1999                  start_time,
2000                  base::Passed(&bitmap_pixels_lock)),
2001       GLHelper::SCALER_QUALITY_GOOD);
2002 }
2003
2004 void RenderWidgetHostViewAndroid::OnStylusSelectBegin(float x0,
2005                                                       float y0,
2006                                                       float x1,
2007                                                       float y1) {
2008   SelectBetweenCoordinates(gfx::PointF(x0, y0), gfx::PointF(x1, y1));
2009 }
2010
2011 void RenderWidgetHostViewAndroid::OnStylusSelectUpdate(float x, float y) {
2012   MoveRangeSelectionExtent(gfx::PointF(x, y));
2013 }
2014
2015 void RenderWidgetHostViewAndroid::OnStylusSelectEnd() {
2016   if (selection_controller_)
2017     selection_controller_->AllowShowingFromCurrentSelection();
2018 }
2019
2020 void RenderWidgetHostViewAndroid::OnStylusSelectTap(base::TimeTicks time,
2021                                                     float x,
2022                                                     float y) {
2023   // Treat the stylus tap as a long press, activating either a word selection or
2024   // context menu depending on the targetted content.
2025   blink::WebGestureEvent long_press = WebGestureEventBuilder::Build(
2026       blink::WebInputEvent::GestureLongPress,
2027       (time - base::TimeTicks()).InSecondsF(), x, y);
2028   SendGestureEvent(long_press);
2029 }
2030
2031 // static
2032 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
2033     blink::WebScreenInfo* results) {
2034   const gfx::Display& display =
2035       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
2036   results->rect = display.bounds();
2037   // TODO(husky): Remove any system controls from availableRect.
2038   results->availableRect = display.work_area();
2039   results->deviceScaleFactor = display.device_scale_factor();
2040   results->orientationAngle = display.RotationAsDegree();
2041   results->orientationType =
2042       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
2043   gfx::DeviceDisplayInfo info;
2044   results->depth = info.GetBitsPerPixel();
2045   results->depthPerComponent = info.GetBitsPerComponent();
2046   results->isMonochrome = (results->depthPerComponent == 0);
2047 }
2048
2049 } // namespace content