src/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/sys_utils.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/threading/worker_pool.h"
  19 #include "cc/base/latency_info_swap_promise.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/output/compositor_frame.h"
  24 #include "cc/output/compositor_frame_ack.h"
  25 #include "cc/output/copy_output_request.h"
  26 #include "cc/output/copy_output_result.h"
  27 #include "cc/resources/single_release_callback.h"
  28 #include "cc/trees/layer_tree_host.h"
  29 #include "content/browser/accessibility/browser_accessibility_manager_android.h"
  30 #include "content/browser/android/content_view_core_impl.h"
  31 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
  32 #include "content/browser/android/overscroll_glow.h"
  33 #include "content/browser/devtools/render_view_devtools_agent_host.h"
  34 #include "content/browser/gpu/compositor_util.h"
  35 #include "content/browser/gpu/gpu_data_manager_impl.h"
  36 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
  37 #include "content/browser/gpu/gpu_surface_tracker.h"
  38 #include "content/browser/media/media_web_contents_observer.h"
  39 #include "content/browser/renderer_host/compositor_impl_android.h"
  40 #include "content/browser/renderer_host/dip_util.h"
  41 #include "content/browser/renderer_host/image_transport_factory_android.h"
  42 #include "content/browser/renderer_host/input/synthetic_gesture_target_android.h"
  43 #include "content/browser/renderer_host/input/web_input_event_builders_android.h"
  44 #include "content/browser/renderer_host/input/web_input_event_util.h"
  45 #include "content/browser/renderer_host/render_process_host_impl.h"
  46 #include "content/browser/renderer_host/render_view_host_impl.h"
  47 #include "content/browser/renderer_host/render_widget_host_impl.h"
  48 #include "content/common/gpu/client/gl_helper.h"
  49 #include "content/common/gpu/gpu_messages.h"
  50 #include "content/common/input/did_overscroll_params.h"
  51 #include "content/common/input_messages.h"
  52 #include "content/common/view_messages.h"
  53 #include "content/public/browser/browser_thread.h"
  54 #include "content/public/browser/devtools_agent_host.h"
  55 #include "content/public/browser/render_view_host.h"
  56 #include "content/public/common/content_switches.h"
  57 #include "gpu/command_buffer/client/gles2_interface.h"
  58 #include "gpu/config/gpu_driver_bug_workaround_type.h"
  59 #include "skia/ext/image_operations.h"
  60 #include "third_party/khronos/GLES2/gl2.h"
  61 #include "third_party/khronos/GLES2/gl2ext.h"
  62 #include "third_party/skia/include/core/SkCanvas.h"
  63 #include "ui/base/android/window_android.h"
  64 #include "ui/base/android/window_android_compositor.h"
  65 #include "ui/events/gesture_detection/gesture_config_helper.h"
  66 #include "ui/events/gesture_detection/motion_event.h"
  67 #include "ui/gfx/android/device_display_info.h"
  68 #include "ui/gfx/android/java_bitmap.h"
  69 #include "ui/gfx/display.h"
  70 #include "ui/gfx/screen.h"
  71 #include "ui/gfx/size_conversions.h"
  72
  73 namespace content {
  74
  75 namespace {
  76
  77 const int kUndefinedOutputSurfaceId = -1;
  78
  79 // Used to accomodate finite precision when comparing scaled viewport and
  80 // content widths. While this value may seem large, width=device-width on an N7
  81 // V1 saw errors of ~0.065 between computed window and content widths.
  82 const float kMobileViewportWidthEpsilon = 0.15f;
  83
  84 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
  85
  86 // Sends an acknowledgement to the renderer of a processed IME event.
  87 void SendImeEventAck(RenderWidgetHostImpl* host) {
  88   host->Send(new ViewMsg_ImeEventAck(host->GetRoutingID()));
  89 }
  90
  91 void CopyFromCompositingSurfaceFinished(
  92     const base::Callback<void(bool, const SkBitmap&)>& callback,
  93     scoped_ptr<cc::SingleReleaseCallback> release_callback,
  94     scoped_ptr<SkBitmap> bitmap,
  95     const base::TimeTicks& start_time,
  96     scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock,
  97     bool result) {
  98   bitmap_pixels_lock.reset();
  99   release_callback->Run(0, false);
 100   UMA_HISTOGRAM_TIMES(kAsyncReadBackString,
 101                       base::TimeTicks::Now() - start_time);
 102   callback.Run(result, *bitmap);
 103 }
 104
 105 ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent& event) {
 106   ui::LatencyInfo latency_info;
 107   // The latency number should only be added if the timestamp is valid.
 108   if (event.timeStampSeconds) {
 109     const int64 time_micros = static_cast<int64>(
 110         event.timeStampSeconds * base::Time::kMicrosecondsPerSecond);
 111     latency_info.AddLatencyNumberWithTimestamp(
 112         ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
 113         0,
 114         0,
 115         base::TimeTicks() + base::TimeDelta::FromMicroseconds(time_micros),
 116         1);
 117   }
 118   return latency_info;
 119 }
 120
 121 OverscrollGlow::DisplayParameters CreateOverscrollDisplayParameters(
 122     const cc::CompositorFrameMetadata& frame_metadata) {
 123   const float scale_factor =
 124       frame_metadata.page_scale_factor * frame_metadata.device_scale_factor;
 125
 126   // Compute the size and offsets for each edge, where each effect is sized to
 127   // the viewport and offset by the distance of each viewport edge to the
 128   // respective content edge.
 129   OverscrollGlow::DisplayParameters params;
 130   params.size = gfx::ScaleSize(frame_metadata.viewport_size, scale_factor);
 131   params.edge_offsets[EdgeEffect::EDGE_TOP] =
 132       -frame_metadata.root_scroll_offset.y() * scale_factor;
 133   params.edge_offsets[EdgeEffect::EDGE_LEFT] =
 134       -frame_metadata.root_scroll_offset.x() * scale_factor;
 135   params.edge_offsets[EdgeEffect::EDGE_BOTTOM] =
 136       (frame_metadata.root_layer_size.height() -
 137        frame_metadata.root_scroll_offset.y() -
 138        frame_metadata.viewport_size.height()) * scale_factor;
 139   params.edge_offsets[EdgeEffect::EDGE_RIGHT] =
 140       (frame_metadata.root_layer_size.width() -
 141        frame_metadata.root_scroll_offset.x() -
 142        frame_metadata.viewport_size.width()) * scale_factor;
 143   params.device_scale_factor = frame_metadata.device_scale_factor;
 144
 145   return params;
 146 }
 147
 148 ui::GestureProvider::Config CreateGestureProviderConfig() {
 149   ui::GestureProvider::Config config = ui::DefaultGestureProviderConfig();
 150   config.disable_click_delay =
 151       CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableClickDelay);
 152   return config;
 153 }
 154
 155 bool HasFixedPageScale(const cc::CompositorFrameMetadata& frame_metadata) {
 156   return frame_metadata.min_page_scale_factor ==
 157          frame_metadata.max_page_scale_factor;
 158 }
 159
 160 bool HasMobileViewport(const cc::CompositorFrameMetadata& frame_metadata) {
 161   float window_width_dip =
 162       frame_metadata.page_scale_factor * frame_metadata.viewport_size.width();
 163   float content_width_css = frame_metadata.root_layer_size.width();
 164   return content_width_css <= window_width_dip + kMobileViewportWidthEpsilon;
 165 }
 166
 167 }  // anonymous namespace
 168
 169 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo(
 170     uint32 output_id,
 171     scoped_ptr<cc::CompositorFrame> output_frame)
 172     : output_surface_id(output_id), frame(output_frame.Pass()) {}
 173
 174 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 175
 176 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
 177     RenderWidgetHostImpl* widget_host,
 178     ContentViewCoreImpl* content_view_core)
 179     : host_(widget_host),
 180       needs_begin_frame_(false),
 181       is_showing_(!widget_host->is_hidden()),
 182       content_view_core_(NULL),
 183       ime_adapter_android_(this),
 184       cached_background_color_(SK_ColorWHITE),
 185       last_output_surface_id_(kUndefinedOutputSurfaceId),
 186       weak_ptr_factory_(this),
 187       overscroll_effect_enabled_(!CommandLine::ForCurrentProcess()->HasSwitch(
 188           switches::kDisableOverscrollEdgeEffect)),
 189       overscroll_effect_(OverscrollGlow::Create(overscroll_effect_enabled_)),
 190       gesture_provider_(CreateGestureProviderConfig(), this),
 191       gesture_text_selector_(this),
 192       flush_input_requested_(false),
 193       accelerated_surface_route_id_(0),
 194       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
 195                                         widget_host->GetProcess()->GetID(),
 196                                         widget_host->GetRoutingID()) != NULL),
 197       frame_evictor_(new DelegatedFrameEvictor(this)),
 198       locks_on_frame_count_(0),
 199       observing_root_window_(false) {
 200   host_->SetView(this);
 201   SetContentViewCore(content_view_core);
 202   ImageTransportFactoryAndroid::AddObserver(this);
 203 }
 204
 205 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
 206   ImageTransportFactoryAndroid::RemoveObserver(this);
 207   SetContentViewCore(NULL);
 208   DCHECK(ack_callbacks_.empty());
 209   if (resource_collection_.get())
 210     resource_collection_->SetClient(NULL);
 211 }
 212
 213
 214 bool RenderWidgetHostViewAndroid::OnMessageReceived(
 215     const IPC::Message& message) {
 216   bool handled = true;
 217   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewAndroid, message)
 218     IPC_MESSAGE_HANDLER(ViewHostMsg_StartContentIntent, OnStartContentIntent)
 219     IPC_MESSAGE_HANDLER(ViewHostMsg_DidChangeBodyBackgroundColor,
 220                         OnDidChangeBodyBackgroundColor)
 221     IPC_MESSAGE_HANDLER(ViewHostMsg_SetNeedsBeginFrame,
 222                         OnSetNeedsBeginFrame)
 223     IPC_MESSAGE_HANDLER(ViewHostMsg_SmartClipDataExtracted,
 224                         OnSmartClipDataExtracted)
 225     IPC_MESSAGE_UNHANDLED(handled = false)
 226   IPC_END_MESSAGE_MAP()
 227   return handled;
 228 }
 229
 230 void RenderWidgetHostViewAndroid::InitAsChild(gfx::NativeView parent_view) {
 231   NOTIMPLEMENTED();
 232 }
 233
 234 void RenderWidgetHostViewAndroid::InitAsPopup(
 235     RenderWidgetHostView* parent_host_view, const gfx::Rect& pos) {
 236   NOTIMPLEMENTED();
 237 }
 238
 239 void RenderWidgetHostViewAndroid::InitAsFullscreen(
 240     RenderWidgetHostView* reference_host_view) {
 241   NOTIMPLEMENTED();
 242 }
 243
 244 RenderWidgetHost*
 245 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
 246   return host_;
 247 }
 248
 249 void RenderWidgetHostViewAndroid::WasShown() {
 250   if (!host_ || !host_->is_hidden())
 251     return;
 252
 253   host_->WasShown();
 254
 255   if (content_view_core_ && !using_synchronous_compositor_) {
 256     content_view_core_->GetWindowAndroid()->AddObserver(this);
 257     content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
 258     observing_root_window_ = true;
 259   }
 260 }
 261
 262 void RenderWidgetHostViewAndroid::WasHidden() {
 263   RunAckCallbacks();
 264
 265   if (!host_ || host_->is_hidden())
 266     return;
 267
 268   // Inform the renderer that we are being hidden so it can reduce its resource
 269   // utilization.
 270   host_->WasHidden();
 271
 272   if (content_view_core_ && !using_synchronous_compositor_) {
 273     content_view_core_->GetWindowAndroid()->RemoveObserver(this);
 274     observing_root_window_ = false;
 275   }
 276 }
 277
 278 void RenderWidgetHostViewAndroid::WasResized() {
 279   host_->WasResized();
 280 }
 281
 282 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
 283   // Ignore the given size as only the Java code has the power to
 284   // resize the view on Android.
 285   default_size_ = size;
 286 }
 287
 288 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
 289   SetSize(rect.size());
 290 }
 291
 292 void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
 293     float scale,
 294     SkBitmap::Config bitmap_config,
 295     gfx::Rect src_subrect,
 296     const base::Callback<void(bool, const SkBitmap&)>& result_callback) {
 297   if (!IsSurfaceAvailableForCopy()) {
 298     result_callback.Run(false, SkBitmap());
 299     return;
 300   }
 301
 302   gfx::Size bounds = layer_->bounds();
 303   if (src_subrect.IsEmpty())
 304     src_subrect = gfx::Rect(bounds);
 305   DCHECK_LE(src_subrect.width() + src_subrect.x(), bounds.width());
 306   DCHECK_LE(src_subrect.height() + src_subrect.y(), bounds.height());
 307   const gfx::Display& display =
 308       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
 309   float device_scale_factor = display.device_scale_factor();
 310   DCHECK_GT(device_scale_factor, 0);
 311   gfx::Size dst_size(
 312       gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale / device_scale_factor)));
 313   CopyFromCompositingSurface(
 314       src_subrect, dst_size, result_callback, bitmap_config);
 315 }
 316
 317 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
 318   if (!content_view_core_)
 319     return false;
 320   if (!layer_)
 321     return false;
 322
 323   if (texture_size_in_layer_.IsEmpty())
 324     return false;
 325
 326   if (!frame_evictor_->HasFrame())
 327     return false;
 328
 329   return true;
 330 }
 331
 332 gfx::NativeView RenderWidgetHostViewAndroid::GetNativeView() const {
 333   return content_view_core_->GetViewAndroid();
 334 }
 335
 336 gfx::NativeViewId RenderWidgetHostViewAndroid::GetNativeViewId() const {
 337   return reinterpret_cast<gfx::NativeViewId>(
 338       const_cast<RenderWidgetHostViewAndroid*>(this));
 339 }
 340
 341 gfx::NativeViewAccessible
 342 RenderWidgetHostViewAndroid::GetNativeViewAccessible() {
 343   NOTIMPLEMENTED();
 344   return NULL;
 345 }
 346
 347 void RenderWidgetHostViewAndroid::MovePluginWindows(
 348     const std::vector<WebPluginGeometry>& moves) {
 349   // We don't have plugin windows on Android. Do nothing. Note: this is called
 350   // from RenderWidgetHost::OnUpdateRect which is itself invoked while
 351   // processing the corresponding message from Renderer.
 352 }
 353
 354 void RenderWidgetHostViewAndroid::Focus() {
 355   host_->Focus();
 356   host_->SetInputMethodActive(true);
 357   if (overscroll_effect_enabled_)
 358     overscroll_effect_->Enable();
 359 }
 360
 361 void RenderWidgetHostViewAndroid::Blur() {
 362   host_->ExecuteEditCommand("Unselect", "");
 363   host_->SetInputMethodActive(false);
 364   host_->Blur();
 365   overscroll_effect_->Disable();
 366 }
 367
 368 bool RenderWidgetHostViewAndroid::HasFocus() const {
 369   if (!content_view_core_)
 370     return false;  // ContentViewCore not created yet.
 371
 372   return content_view_core_->HasFocus();
 373 }
 374
 375 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
 376   return HasValidFrame();
 377 }
 378
 379 void RenderWidgetHostViewAndroid::Show() {
 380   if (is_showing_)
 381     return;
 382
 383   is_showing_ = true;
 384   if (layer_)
 385     layer_->SetHideLayerAndSubtree(false);
 386
 387   frame_evictor_->SetVisible(true);
 388   WasShown();
 389 }
 390
 391 void RenderWidgetHostViewAndroid::Hide() {
 392   if (!is_showing_)
 393     return;
 394
 395   is_showing_ = false;
 396   if (layer_ && locks_on_frame_count_ == 0)
 397     layer_->SetHideLayerAndSubtree(true);
 398
 399   frame_evictor_->SetVisible(false);
 400   WasHidden();
 401 }
 402
 403 bool RenderWidgetHostViewAndroid::IsShowing() {
 404   // ContentViewCoreImpl represents the native side of the Java
 405   // ContentViewCore.  It being NULL means that it is not attached
 406   // to the View system yet, so we treat this RWHVA as hidden.
 407   return is_showing_ && content_view_core_;
 408 }
 409
 410 void RenderWidgetHostViewAndroid::LockCompositingSurface() {
 411   DCHECK(HasValidFrame());
 412   DCHECK(host_);
 413   DCHECK(frame_evictor_->HasFrame());
 414   frame_evictor_->LockFrame();
 415   locks_on_frame_count_++;
 416 }
 417
 418 void RenderWidgetHostViewAndroid::UnlockCompositingSurface() {
 419   if (!frame_evictor_->HasFrame() || locks_on_frame_count_ == 0)
 420     return;
 421
 422   DCHECK(HasValidFrame());
 423   frame_evictor_->UnlockFrame();
 424   locks_on_frame_count_--;
 425
 426   if (locks_on_frame_count_ == 0) {
 427     if (last_frame_info_) {
 428       InternalSwapCompositorFrame(last_frame_info_->output_surface_id,
 429                                   last_frame_info_->frame.Pass());
 430       last_frame_info_.reset();
 431     }
 432
 433     if (!is_showing_ && layer_)
 434       layer_->SetHideLayerAndSubtree(true);
 435   }
 436 }
 437
 438 void RenderWidgetHostViewAndroid::SetTextSurroundingSelectionCallback(
 439     const TextSurroundingSelectionCallback& callback) {
 440   // Only one outstanding request is allowed at any given time.
 441   DCHECK(!callback.is_null());
 442   text_surrounding_selection_callback_ = callback;
 443 }
 444
 445 void RenderWidgetHostViewAndroid::OnTextSurroundingSelectionResponse(
 446     const base::string16& content,
 447     size_t start_offset,
 448     size_t end_offset) {
 449   if (text_surrounding_selection_callback_.is_null())
 450     return;
 451   text_surrounding_selection_callback_.Run(content, start_offset, end_offset);
 452   text_surrounding_selection_callback_.Reset();
 453 }
 454
 455 void RenderWidgetHostViewAndroid::ReleaseLocksOnSurface() {
 456   if (!frame_evictor_->HasFrame()) {
 457     DCHECK_EQ(locks_on_frame_count_, 0u);
 458     return;
 459   }
 460   while (locks_on_frame_count_ > 0) {
 461     UnlockCompositingSurface();
 462   }
 463   RunAckCallbacks();
 464 }
 465
 466 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
 467   if (!content_view_core_)
 468     return gfx::Rect(default_size_);
 469
 470   return gfx::Rect(content_view_core_->GetViewSize());
 471 }
 472
 473 gfx::Size RenderWidgetHostViewAndroid::GetPhysicalBackingSize() const {
 474   if (!content_view_core_)
 475     return gfx::Size();
 476
 477   return content_view_core_->GetPhysicalBackingSize();
 478 }
 479
 480 float RenderWidgetHostViewAndroid::GetOverdrawBottomHeight() const {
 481   if (!content_view_core_)
 482     return 0.f;
 483
 484   return content_view_core_->GetOverdrawBottomHeightDip();
 485 }
 486
 487 void RenderWidgetHostViewAndroid::UpdateCursor(const WebCursor& cursor) {
 488   // There are no cursors on Android.
 489 }
 490
 491 void RenderWidgetHostViewAndroid::SetIsLoading(bool is_loading) {
 492   // Do nothing. The UI notification is handled through ContentViewClient which
 493   // is TabContentsDelegate.
 494 }
 495
 496 long RenderWidgetHostViewAndroid::GetNativeImeAdapter() {
 497   return reinterpret_cast<intptr_t>(&ime_adapter_android_);
 498 }
 499
 500 void RenderWidgetHostViewAndroid::TextInputStateChanged(
 501     const ViewHostMsg_TextInputState_Params& params) {
 502   // If the change is not originated from IME (e.g. Javascript, autofill),
 503   // send back the renderer an acknowledgement, regardless of how we exit from
 504   // this method.
 505   base::ScopedClosureRunner ack_caller;
 506   if (params.is_non_ime_change)
 507     ack_caller.Reset(base::Bind(&SendImeEventAck, host_));
 508
 509   if (!IsShowing())
 510     return;
 511
 512   content_view_core_->UpdateImeAdapter(
 513       GetNativeImeAdapter(),
 514       static_cast<int>(params.type),
 515       params.value, params.selection_start, params.selection_end,
 516       params.composition_start, params.composition_end,
 517       params.show_ime_if_needed, params.is_non_ime_change);
 518 }
 519
 520 void RenderWidgetHostViewAndroid::OnDidChangeBodyBackgroundColor(
 521     SkColor color) {
 522   if (cached_background_color_ == color)
 523     return;
 524
 525   cached_background_color_ = color;
 526   if (content_view_core_)
 527     content_view_core_->OnBackgroundColorChanged(color);
 528 }
 529
 530 void RenderWidgetHostViewAndroid::OnSetNeedsBeginFrame(bool enabled) {
 531   if (enabled == needs_begin_frame_)
 532     return;
 533
 534   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::OnSetNeedsBeginFrame",
 535                "enabled", enabled);
 536   if (content_view_core_ && enabled)
 537     content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
 538
 539   needs_begin_frame_ = enabled;
 540 }
 541
 542 void RenderWidgetHostViewAndroid::OnStartContentIntent(
 543     const GURL& content_url) {
 544   if (content_view_core_)
 545     content_view_core_->StartContentIntent(content_url);
 546 }
 547
 548 void RenderWidgetHostViewAndroid::OnSmartClipDataExtracted(
 549     const base::string16& text,
 550     const base::string16& html,
 551     const gfx::Rect rect) {
 552   if (content_view_core_)
 553     content_view_core_->OnSmartClipDataExtracted(text, html, rect);
 554 }
 555
 556 bool RenderWidgetHostViewAndroid::OnTouchEvent(
 557     const ui::MotionEvent& event) {
 558   if (!host_)
 559     return false;
 560
 561   if (!gesture_provider_.OnTouchEvent(event))
 562     return false;
 563
 564   if (gesture_text_selector_.OnTouchEvent(event)) {
 565     gesture_provider_.OnTouchEventAck(false);
 566     return true;
 567   }
 568
 569   // Short-circuit touch forwarding if no touch handlers exist.
 570   if (!host_->ShouldForwardTouchEvent()) {
 571     const bool event_consumed = false;
 572     gesture_provider_.OnTouchEventAck(event_consumed);
 573     return true;
 574   }
 575
 576   SendTouchEvent(CreateWebTouchEventFromMotionEvent(event));
 577   return true;
 578 }
 579
 580 void RenderWidgetHostViewAndroid::ResetGestureDetection() {
 581   const ui::MotionEvent* current_down_event =
 582       gesture_provider_.GetCurrentDownEvent();
 583   if (!current_down_event)
 584     return;
 585
 586   scoped_ptr<ui::MotionEvent> cancel_event = current_down_event->Cancel();
 587   DCHECK(cancel_event);
 588   OnTouchEvent(*cancel_event);
 589 }
 590
 591 void RenderWidgetHostViewAndroid::SetDoubleTapSupportEnabled(bool enabled) {
 592   gesture_provider_.SetDoubleTapSupportForPlatformEnabled(enabled);
 593 }
 594
 595 void RenderWidgetHostViewAndroid::SetMultiTouchZoomSupportEnabled(
 596     bool enabled) {
 597   gesture_provider_.SetMultiTouchZoomSupportEnabled(enabled);
 598 }
 599
 600 void RenderWidgetHostViewAndroid::ImeCancelComposition() {
 601   ime_adapter_android_.CancelComposition();
 602 }
 603
 604 void RenderWidgetHostViewAndroid::FocusedNodeChanged(bool is_editable_node) {
 605   ime_adapter_android_.FocusedNodeChanged(is_editable_node);
 606 }
 607
 608 void RenderWidgetHostViewAndroid::RenderProcessGone(
 609     base::TerminationStatus status, int error_code) {
 610   Destroy();
 611 }
 612
 613 void RenderWidgetHostViewAndroid::Destroy() {
 614   RemoveLayers();
 615   SetContentViewCore(NULL);
 616
 617   // The RenderWidgetHost's destruction led here, so don't call it.
 618   host_ = NULL;
 619
 620   delete this;
 621 }
 622
 623 void RenderWidgetHostViewAndroid::SetTooltipText(
 624     const base::string16& tooltip_text) {
 625   // Tooltips don't makes sense on Android.
 626 }
 627
 628 void RenderWidgetHostViewAndroid::SelectionChanged(const base::string16& text,
 629                                                    size_t offset,
 630                                                    const gfx::Range& range) {
 631   RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 632
 633   if (text.empty() || range.is_empty() || !content_view_core_)
 634     return;
 635   size_t pos = range.GetMin() - offset;
 636   size_t n = range.length();
 637
 638   DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
 639   if (pos >= text.length()) {
 640     NOTREACHED() << "The text can not cover range.";
 641     return;
 642   }
 643
 644   std::string utf8_selection = base::UTF16ToUTF8(text.substr(pos, n));
 645
 646   content_view_core_->OnSelectionChanged(utf8_selection);
 647 }
 648
 649 void RenderWidgetHostViewAndroid::SelectionBoundsChanged(
 650     const ViewHostMsg_SelectionBounds_Params& params) {
 651   if (content_view_core_) {
 652     content_view_core_->OnSelectionBoundsChanged(params);
 653   }
 654 }
 655
 656 void RenderWidgetHostViewAndroid::ScrollOffsetChanged() {
 657 }
 658
 659 void RenderWidgetHostViewAndroid::SetBackgroundOpaque(bool opaque) {
 660   RenderWidgetHostViewBase::SetBackgroundOpaque(opaque);
 661   host_->SetBackgroundOpaque(opaque);
 662 }
 663
 664 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
 665     const gfx::Rect& src_subrect,
 666     const gfx::Size& dst_size,
 667     const base::Callback<void(bool, const SkBitmap&)>& callback,
 668     const SkBitmap::Config bitmap_config) {
 669   if (!IsReadbackConfigSupported(bitmap_config)) {
 670     callback.Run(false, SkBitmap());
 671     return;
 672   }
 673   base::TimeTicks start_time = base::TimeTicks::Now();
 674   if (!using_synchronous_compositor_ && !IsSurfaceAvailableForCopy()) {
 675     callback.Run(false, SkBitmap());
 676     return;
 677   }
 678   const gfx::Display& display =
 679       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
 680   float device_scale_factor = display.device_scale_factor();
 681   gfx::Size dst_size_in_pixel =
 682       ConvertRectToPixel(device_scale_factor, gfx::Rect(dst_size)).size();
 683   gfx::Rect src_subrect_in_pixel =
 684       ConvertRectToPixel(device_scale_factor, src_subrect);
 685
 686   if (using_synchronous_compositor_) {
 687     SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback,
 688                             bitmap_config);
 689     UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
 690                         base::TimeTicks::Now() - start_time);
 691     return;
 692   }
 693
 694   scoped_ptr<cc::CopyOutputRequest> request;
 695   scoped_refptr<cc::Layer> readback_layer;
 696   DCHECK(content_view_core_);
 697   DCHECK(content_view_core_->GetWindowAndroid());
 698   ui::WindowAndroidCompositor* compositor =
 699       content_view_core_->GetWindowAndroid()->GetCompositor();
 700   DCHECK(compositor);
 701   DCHECK(frame_provider_);
 702   scoped_refptr<cc::DelegatedRendererLayer> delegated_layer =
 703       cc::DelegatedRendererLayer::Create(frame_provider_);
 704   delegated_layer->SetBounds(content_size_in_layer_);
 705   delegated_layer->SetHideLayerAndSubtree(true);
 706   delegated_layer->SetIsDrawable(true);
 707   delegated_layer->SetContentsOpaque(true);
 708   compositor->AttachLayerForReadback(delegated_layer);
 709
 710   readback_layer = delegated_layer;
 711   request = cc::CopyOutputRequest::CreateRequest(
 712       base::Bind(&RenderWidgetHostViewAndroid::
 713                      PrepareTextureCopyOutputResultForDelegatedReadback,
 714                  dst_size_in_pixel,
 715                  bitmap_config,
 716                  start_time,
 717                  readback_layer,
 718                  callback));
 719   request->set_area(src_subrect_in_pixel);
 720   readback_layer->RequestCopyOfOutput(request.Pass());
 721 }
 722
 723 void RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceToVideoFrame(
 724       const gfx::Rect& src_subrect,
 725       const scoped_refptr<media::VideoFrame>& target,
 726       const base::Callback<void(bool)>& callback) {
 727   NOTIMPLEMENTED();
 728   callback.Run(false);
 729 }
 730
 731 bool RenderWidgetHostViewAndroid::CanCopyToVideoFrame() const {
 732   return false;
 733 }
 734
 735 void RenderWidgetHostViewAndroid::ShowDisambiguationPopup(
 736     const gfx::Rect& target_rect, const SkBitmap& zoomed_bitmap) {
 737   if (!content_view_core_)
 738     return;
 739
 740   content_view_core_->ShowDisambiguationPopup(target_rect, zoomed_bitmap);
 741 }
 742
 743 scoped_ptr<SyntheticGestureTarget>
 744 RenderWidgetHostViewAndroid::CreateSyntheticGestureTarget() {
 745   return scoped_ptr<SyntheticGestureTarget>(new SyntheticGestureTargetAndroid(
 746       host_, content_view_core_->CreateTouchEventSynthesizer()));
 747 }
 748
 749 void RenderWidgetHostViewAndroid::SendDelegatedFrameAck(
 750     uint32 output_surface_id) {
 751   DCHECK(host_);
 752   cc::CompositorFrameAck ack;
 753   if (resource_collection_.get())
 754     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 755   RenderWidgetHostImpl::SendSwapCompositorFrameAck(host_->GetRoutingID(),
 756                                                    output_surface_id,
 757                                                    host_->GetProcess()->GetID(),
 758                                                    ack);
 759 }
 760
 761 void RenderWidgetHostViewAndroid::SendReturnedDelegatedResources(
 762     uint32 output_surface_id) {
 763   DCHECK(resource_collection_);
 764
 765   cc::CompositorFrameAck ack;
 766   resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 767   DCHECK(!ack.resources.empty());
 768
 769   RenderWidgetHostImpl::SendReclaimCompositorResources(
 770       host_->GetRoutingID(),
 771       output_surface_id,
 772       host_->GetProcess()->GetID(),
 773       ack);
 774 }
 775
 776 void RenderWidgetHostViewAndroid::UnusedResourcesAreAvailable() {
 777   if (ack_callbacks_.size())
 778     return;
 779   SendReturnedDelegatedResources(last_output_surface_id_);
 780 }
 781
 782 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
 783   RemoveLayers();
 784   frame_provider_ = NULL;
 785   layer_ = NULL;
 786 }
 787
 788 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
 789     uint32 output_surface_id,
 790     scoped_ptr<cc::DelegatedFrameData> frame_data) {
 791   bool has_content = !texture_size_in_layer_.IsEmpty();
 792
 793   if (output_surface_id != last_output_surface_id_) {
 794     // Drop the cc::DelegatedFrameResourceCollection so that we will not return
 795     // any resources from the old output surface with the new output surface id.
 796     if (resource_collection_.get()) {
 797       resource_collection_->SetClient(NULL);
 798       if (resource_collection_->LoseAllResources())
 799         SendReturnedDelegatedResources(last_output_surface_id_);
 800       resource_collection_ = NULL;
 801     }
 802     DestroyDelegatedContent();
 803
 804     last_output_surface_id_ = output_surface_id;
 805   }
 806
 807   // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the
 808   // renderer frame, assuming that the browser compositor will scale
 809   // it back up to device scale.  But on Android we put our browser layers in
 810   // physical pixels and set our browser CC device_scale_factor to 1, so this
 811   // suppresses the transform.  This line may need to be removed when fixing
 812   // http://crbug.com/384134 or http://crbug.com/310763
 813   frame_data->device_scale_factor = 1.0f;
 814
 815   if (!has_content) {
 816     DestroyDelegatedContent();
 817   } else {
 818     if (!resource_collection_.get()) {
 819       resource_collection_ = new cc::DelegatedFrameResourceCollection;
 820       resource_collection_->SetClient(this);
 821     }
 822     if (!frame_provider_ ||
 823         texture_size_in_layer_ != frame_provider_->frame_size()) {
 824       RemoveLayers();
 825       frame_provider_ = new cc::DelegatedFrameProvider(
 826           resource_collection_.get(), frame_data.Pass());
 827       layer_ = cc::DelegatedRendererLayer::Create(frame_provider_);
 828       AttachLayers();
 829     } else {
 830       frame_provider_->SetFrameData(frame_data.Pass());
 831     }
 832   }
 833
 834   if (layer_.get()) {
 835     layer_->SetIsDrawable(true);
 836     layer_->SetContentsOpaque(true);
 837     layer_->SetBounds(content_size_in_layer_);
 838     layer_->SetNeedsDisplay();
 839   }
 840
 841   base::Closure ack_callback =
 842       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
 843                  weak_ptr_factory_.GetWeakPtr(),
 844                  output_surface_id);
 845
 846   ack_callbacks_.push(ack_callback);
 847   if (host_->is_hidden())
 848     RunAckCallbacks();
 849 }
 850
 851 void RenderWidgetHostViewAndroid::ComputeContentsSize(
 852     const cc::CompositorFrameMetadata& frame_metadata) {
 853   // Calculate the content size.  This should be 0 if the texture_size is 0.
 854   gfx::Vector2dF offset;
 855   if (texture_size_in_layer_.GetArea() > 0)
 856     offset = frame_metadata.location_bar_content_translation;
 857   offset.set_y(offset.y() + frame_metadata.overdraw_bottom_height);
 858   offset.Scale(frame_metadata.device_scale_factor);
 859   content_size_in_layer_ =
 860       gfx::Size(texture_size_in_layer_.width() - offset.x(),
 861                 texture_size_in_layer_.height() - offset.y());
 862
 863   overscroll_effect_->UpdateDisplayParameters(
 864       CreateOverscrollDisplayParameters(frame_metadata));
 865 }
 866
 867 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
 868     uint32 output_surface_id,
 869     scoped_ptr<cc::CompositorFrame> frame) {
 870   if (!frame->delegated_frame_data) {
 871     LOG(ERROR) << "Non-delegated renderer path no longer supported";
 872     return;
 873   }
 874
 875   if (locks_on_frame_count_ > 0) {
 876     DCHECK(HasValidFrame());
 877     RetainFrame(output_surface_id, frame.Pass());
 878     return;
 879   }
 880
 881   if (layer_ && layer_->layer_tree_host()) {
 882     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
 883       scoped_ptr<cc::SwapPromise> swap_promise(
 884           new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
 885       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
 886     }
 887   }
 888
 889   DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
 890
 891   cc::RenderPass* root_pass =
 892       frame->delegated_frame_data->render_pass_list.back();
 893   texture_size_in_layer_ = root_pass->output_rect.size();
 894   ComputeContentsSize(frame->metadata);
 895
 896   SwapDelegatedFrame(output_surface_id, frame->delegated_frame_data.Pass());
 897   frame_evictor_->SwappedFrame(!host_->is_hidden());
 898
 899   OnFrameMetadataUpdated(frame->metadata);
 900 }
 901
 902 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
 903     uint32 output_surface_id,
 904     scoped_ptr<cc::CompositorFrame> frame) {
 905   InternalSwapCompositorFrame(output_surface_id, frame.Pass());
 906 }
 907
 908 void RenderWidgetHostViewAndroid::RetainFrame(
 909     uint32 output_surface_id,
 910     scoped_ptr<cc::CompositorFrame> frame) {
 911   DCHECK(locks_on_frame_count_);
 912
 913   // Store the incoming frame so that it can be swapped when all the locks have
 914   // been released. If there is already a stored frame, then replace and skip
 915   // the previous one but make sure we still eventually send the ACK. Holding
 916   // the ACK also blocks the renderer when its max_frames_pending is reached.
 917   if (last_frame_info_) {
 918     base::Closure ack_callback =
 919         base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
 920                    weak_ptr_factory_.GetWeakPtr(),
 921                    last_frame_info_->output_surface_id);
 922
 923     ack_callbacks_.push(ack_callback);
 924   }
 925
 926   last_frame_info_.reset(new LastFrameInfo(output_surface_id, frame.Pass()));
 927 }
 928
 929 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
 930     const cc::CompositorFrameMetadata& frame_metadata) {
 931   // This is a subset of OnSwapCompositorFrame() used in the synchronous
 932   // compositor flow.
 933   OnFrameMetadataUpdated(frame_metadata);
 934   ComputeContentsSize(frame_metadata);
 935
 936   // DevTools ScreenCast support for Android WebView.
 937   if (DevToolsAgentHost::HasFor(RenderViewHost::From(GetRenderWidgetHost()))) {
 938     scoped_refptr<DevToolsAgentHost> dtah =
 939         DevToolsAgentHost::GetOrCreateFor(
 940             RenderViewHost::From(GetRenderWidgetHost()));
 941     // Unblock the compositor.
 942     BrowserThread::PostTask(
 943         BrowserThread::UI, FROM_HERE,
 944         base::Bind(&RenderViewDevToolsAgentHost::SynchronousSwapCompositorFrame,
 945                    static_cast<RenderViewDevToolsAgentHost*>(dtah.get()),
 946                    frame_metadata));
 947   }
 948 }
 949
 950 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
 951   if (layer_)
 952     layer_->SetContentsOpaque(!enabled);
 953 }
 954
 955 void RenderWidgetHostViewAndroid::SynchronousCopyContents(
 956     const gfx::Rect& src_subrect_in_pixel,
 957     const gfx::Size& dst_size_in_pixel,
 958     const base::Callback<void(bool, const SkBitmap&)>& callback,
 959     const SkBitmap::Config config) {
 960   SynchronousCompositor* compositor =
 961       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
 962                                         host_->GetRoutingID());
 963   if (!compositor) {
 964     callback.Run(false, SkBitmap());
 965     return;
 966   }
 967
 968   SkBitmap bitmap;
 969   bitmap.setConfig(config,
 970                    dst_size_in_pixel.width(),
 971                    dst_size_in_pixel.height());
 972   bitmap.allocPixels();
 973   SkCanvas canvas(bitmap);
 974   canvas.scale(
 975       (float)dst_size_in_pixel.width() / (float)src_subrect_in_pixel.width(),
 976       (float)dst_size_in_pixel.height() / (float)src_subrect_in_pixel.height());
 977   compositor->DemandDrawSw(&canvas);
 978   callback.Run(true, bitmap);
 979 }
 980
 981 void RenderWidgetHostViewAndroid::OnFrameMetadataUpdated(
 982     const cc::CompositorFrameMetadata& frame_metadata) {
 983
 984   // Disable double tap zoom for pages that have a width=device-width or
 985   // narrower viewport (indicating that this is a mobile-optimized or responsive
 986   // web design, so text will be legible without zooming). Also disable
 987   // double tap and pinch for pages that prevent zooming in or out.
 988   bool has_mobile_viewport = HasMobileViewport(frame_metadata);
 989   bool has_fixed_page_scale = HasFixedPageScale(frame_metadata);
 990   gesture_provider_.SetDoubleTapSupportForPageEnabled(
 991       !has_fixed_page_scale && !has_mobile_viewport);
 992
 993   if (!content_view_core_)
 994     return;
 995   // All offsets and sizes are in CSS pixels.
 996   content_view_core_->UpdateFrameInfo(
 997       frame_metadata.root_scroll_offset,
 998       frame_metadata.page_scale_factor,
 999       gfx::Vector2dF(frame_metadata.min_page_scale_factor,
1000                      frame_metadata.max_page_scale_factor),
1001       frame_metadata.root_layer_size,
1002       frame_metadata.viewport_size,
1003       frame_metadata.location_bar_offset,
1004       frame_metadata.location_bar_content_translation,
1005       frame_metadata.overdraw_bottom_height);
1006 #if defined(VIDEO_HOLE)
1007   if (host_ && host_->IsRenderView()) {
1008     RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(
1009         RenderViewHost::From(host_));
1010     rvhi->media_web_contents_observer()->OnFrameInfoUpdated();
1011   }
1012 #endif  // defined(VIDEO_HOLE)
1013 }
1014
1015 void RenderWidgetHostViewAndroid::AcceleratedSurfaceInitialized(int host_id,
1016                                                                 int route_id) {
1017   accelerated_surface_route_id_ = route_id;
1018 }
1019
1020 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
1021     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
1022     int gpu_host_id) {
1023   NOTREACHED() << "Need --composite-to-mailbox or --enable-delegated-renderer";
1024 }
1025
1026 void RenderWidgetHostViewAndroid::AttachLayers() {
1027   if (!content_view_core_)
1028     return;
1029   if (!layer_.get())
1030     return;
1031
1032   content_view_core_->AttachLayer(layer_);
1033   if (overscroll_effect_enabled_)
1034     overscroll_effect_->Enable();
1035   layer_->SetHideLayerAndSubtree(!is_showing_);
1036 }
1037
1038 void RenderWidgetHostViewAndroid::RemoveLayers() {
1039   if (!content_view_core_)
1040     return;
1041   if (!layer_.get())
1042     return;
1043
1044   content_view_core_->RemoveLayer(layer_);
1045   overscroll_effect_->Disable();
1046 }
1047
1048 void RenderWidgetHostViewAndroid::SetNeedsAnimate() {
1049   content_view_core_->GetWindowAndroid()->SetNeedsAnimate();
1050 }
1051
1052 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
1053   return overscroll_effect_->Animate(frame_time);
1054 }
1055
1056 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
1057     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
1058     int gpu_host_id) {
1059   NOTREACHED();
1060 }
1061
1062 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
1063   NOTREACHED();
1064 }
1065
1066 void RenderWidgetHostViewAndroid::AcceleratedSurfaceRelease() {
1067   NOTREACHED();
1068 }
1069
1070 void RenderWidgetHostViewAndroid::EvictDelegatedFrame() {
1071   if (layer_.get())
1072     DestroyDelegatedContent();
1073   frame_evictor_->DiscardedFrame();
1074 }
1075
1076 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
1077     const gfx::Size& desired_size) {
1078   NOTREACHED();
1079   return false;
1080 }
1081
1082 void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* result) {
1083   // ScreenInfo isn't tied to the widget on Android. Always return the default.
1084   RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
1085 }
1086
1087 // TODO(jrg): Find out the implications and answer correctly here,
1088 // as we are returning the WebView and not root window bounds.
1089 gfx::Rect RenderWidgetHostViewAndroid::GetBoundsInRootWindow() {
1090   return GetViewBounds();
1091 }
1092
1093 gfx::GLSurfaceHandle RenderWidgetHostViewAndroid::GetCompositingSurface() {
1094   gfx::GLSurfaceHandle handle =
1095       gfx::GLSurfaceHandle(gfx::kNullPluginWindow, gfx::NATIVE_TRANSPORT);
1096   if (CompositorImpl::IsInitialized()) {
1097     handle.parent_client_id =
1098         ImageTransportFactoryAndroid::GetInstance()->GetChannelID();
1099   }
1100   return handle;
1101 }
1102
1103 void RenderWidgetHostViewAndroid::ProcessAckedTouchEvent(
1104     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
1105   const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
1106   gesture_provider_.OnTouchEventAck(event_consumed);
1107 }
1108
1109 void RenderWidgetHostViewAndroid::GestureEventAck(
1110     const blink::WebGestureEvent& event,
1111     InputEventAckState ack_result) {
1112   if (content_view_core_)
1113     content_view_core_->OnGestureEventAck(event, ack_result);
1114 }
1115
1116 InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
1117     const blink::WebInputEvent& input_event) {
1118   if (content_view_core_ &&
1119       content_view_core_->FilterInputEvent(input_event))
1120     return INPUT_EVENT_ACK_STATE_CONSUMED;
1121
1122   if (!host_)
1123     return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1124
1125   if (input_event.type == blink::WebInputEvent::GestureTapDown ||
1126       input_event.type == blink::WebInputEvent::TouchStart) {
1127     GpuDataManagerImpl* gpu_data = GpuDataManagerImpl::GetInstance();
1128     GpuProcessHostUIShim* shim = GpuProcessHostUIShim::GetOneInstance();
1129     if (shim && gpu_data && accelerated_surface_route_id_ &&
1130         gpu_data->IsDriverBugWorkaroundActive(gpu::WAKE_UP_GPU_BEFORE_DRAWING))
1131       shim->Send(
1132           new AcceleratedSurfaceMsg_WakeUpGpu(accelerated_surface_route_id_));
1133   }
1134
1135   SynchronousCompositorImpl* compositor =
1136       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
1137                                           host_->GetRoutingID());
1138   if (compositor)
1139     return compositor->HandleInputEvent(input_event);
1140   return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1141 }
1142
1143 void RenderWidgetHostViewAndroid::OnSetNeedsFlushInput() {
1144   if (flush_input_requested_ || !content_view_core_)
1145     return;
1146   TRACE_EVENT0("input", "RenderWidgetHostViewAndroid::OnSetNeedsFlushInput");
1147   flush_input_requested_ = true;
1148   content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
1149 }
1150
1151 void RenderWidgetHostViewAndroid::CreateBrowserAccessibilityManagerIfNeeded() {
1152   if (!host_ || host_->accessibility_mode() != AccessibilityModeComplete)
1153     return;
1154
1155   if (!GetBrowserAccessibilityManager()) {
1156     base::android::ScopedJavaLocalRef<jobject> obj;
1157     if (content_view_core_)
1158       obj = content_view_core_->GetJavaObject();
1159     SetBrowserAccessibilityManager(
1160         new BrowserAccessibilityManagerAndroid(
1161             obj,
1162             BrowserAccessibilityManagerAndroid::GetEmptyDocument(),
1163             host_));
1164   }
1165 }
1166
1167 bool RenderWidgetHostViewAndroid::LockMouse() {
1168   NOTIMPLEMENTED();
1169   return false;
1170 }
1171
1172 void RenderWidgetHostViewAndroid::UnlockMouse() {
1173   NOTIMPLEMENTED();
1174 }
1175
1176 // Methods called from the host to the render
1177
1178 void RenderWidgetHostViewAndroid::SendKeyEvent(
1179     const NativeWebKeyboardEvent& event) {
1180   if (host_)
1181     host_->ForwardKeyboardEvent(event);
1182 }
1183
1184 void RenderWidgetHostViewAndroid::SendTouchEvent(
1185     const blink::WebTouchEvent& event) {
1186   if (host_)
1187     host_->ForwardTouchEventWithLatencyInfo(event, CreateLatencyInfo(event));
1188
1189   // Send a proactive BeginFrame on the next vsync to reduce latency.
1190   // This is good enough as long as the first touch event has Begin semantics
1191   // and the actual scroll happens on the next vsync.
1192   // TODO: Is this actually still needed?
1193   if (content_view_core_) {
1194     content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
1195   }
1196 }
1197
1198 void RenderWidgetHostViewAndroid::SendMouseEvent(
1199     const blink::WebMouseEvent& event) {
1200   if (host_)
1201     host_->ForwardMouseEvent(event);
1202 }
1203
1204 void RenderWidgetHostViewAndroid::SendMouseWheelEvent(
1205     const blink::WebMouseWheelEvent& event) {
1206   if (host_)
1207     host_->ForwardWheelEvent(event);
1208 }
1209
1210 void RenderWidgetHostViewAndroid::SendGestureEvent(
1211     const blink::WebGestureEvent& event) {
1212   // Sending a gesture that may trigger overscroll should resume the effect.
1213   if (overscroll_effect_enabled_)
1214    overscroll_effect_->Enable();
1215
1216   if (host_)
1217     host_->ForwardGestureEventWithLatencyInfo(event, CreateLatencyInfo(event));
1218 }
1219
1220 void RenderWidgetHostViewAndroid::MoveCaret(const gfx::Point& point) {
1221   if (host_)
1222     host_->MoveCaret(point);
1223 }
1224
1225 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
1226   return cached_background_color_;
1227 }
1228
1229 void RenderWidgetHostViewAndroid::DidOverscroll(
1230     const DidOverscrollParams& params) {
1231   if (!content_view_core_ || !layer_ || !is_showing_)
1232     return;
1233
1234   const float device_scale_factor = content_view_core_->GetDpiScale();
1235   if (overscroll_effect_->OnOverscrolled(
1236           content_view_core_->GetLayer(),
1237           base::TimeTicks::Now(),
1238           gfx::ScaleVector2d(params.accumulated_overscroll,
1239                              device_scale_factor),
1240           gfx::ScaleVector2d(params.latest_overscroll_delta,
1241                              device_scale_factor),
1242           gfx::ScaleVector2d(params.current_fling_velocity,
1243                              device_scale_factor))) {
1244     SetNeedsAnimate();
1245   }
1246 }
1247
1248 void RenderWidgetHostViewAndroid::DidStopFlinging() {
1249   if (content_view_core_)
1250     content_view_core_->DidStopFlinging();
1251 }
1252
1253 void RenderWidgetHostViewAndroid::SetContentViewCore(
1254     ContentViewCoreImpl* content_view_core) {
1255   RemoveLayers();
1256   if (observing_root_window_ && content_view_core_) {
1257     content_view_core_->GetWindowAndroid()->RemoveObserver(this);
1258     observing_root_window_ = false;
1259   }
1260
1261   bool resize = false;
1262   if (content_view_core != content_view_core_) {
1263     ReleaseLocksOnSurface();
1264     resize = true;
1265   }
1266
1267   content_view_core_ = content_view_core;
1268
1269   if (GetBrowserAccessibilityManager()) {
1270     base::android::ScopedJavaLocalRef<jobject> obj;
1271     if (content_view_core_)
1272       obj = content_view_core_->GetJavaObject();
1273     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerAndroid()->
1274         SetContentViewCore(obj);
1275   }
1276
1277   AttachLayers();
1278   if (content_view_core_ && !using_synchronous_compositor_) {
1279     content_view_core_->GetWindowAndroid()->AddObserver(this);
1280     observing_root_window_ = true;
1281     if (needs_begin_frame_)
1282       content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
1283   }
1284
1285   if (resize && content_view_core_)
1286     WasResized();
1287 }
1288
1289 void RenderWidgetHostViewAndroid::RunAckCallbacks() {
1290   while (!ack_callbacks_.empty()) {
1291     ack_callbacks_.front().Run();
1292     ack_callbacks_.pop();
1293   }
1294 }
1295
1296 void RenderWidgetHostViewAndroid::OnGestureEvent(
1297     const ui::GestureEventData& gesture) {
1298   if (gesture_text_selector_.OnGestureEvent(gesture))
1299     return;
1300
1301   SendGestureEvent(CreateWebGestureEventFromGestureEventData(gesture));
1302 }
1303
1304 void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
1305   RunAckCallbacks();
1306 }
1307
1308 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
1309   DCHECK(content_view_core_);
1310   DCHECK(!using_synchronous_compositor_);
1311   RunAckCallbacks();
1312 }
1313
1314 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
1315                                           base::TimeDelta vsync_period) {
1316   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::OnVSync");
1317   if (!host_)
1318     return;
1319
1320   if (flush_input_requested_) {
1321     flush_input_requested_ = false;
1322     host_->FlushInput();
1323   }
1324
1325   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::SendBeginFrame");
1326   base::TimeTicks display_time = frame_time + vsync_period;
1327
1328   // TODO(brianderson): Use adaptive draw-time estimation.
1329   base::TimeDelta estimated_browser_composite_time =
1330       base::TimeDelta::FromMicroseconds(
1331           (1.0f * base::Time::kMicrosecondsPerSecond) / (3.0f * 60));
1332
1333   base::TimeTicks deadline = display_time - estimated_browser_composite_time;
1334
1335   host_->Send(new ViewMsg_BeginFrame(
1336       host_->GetRoutingID(),
1337       cc::BeginFrameArgs::Create(frame_time, deadline, vsync_period)));
1338
1339   if (needs_begin_frame_)
1340     content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
1341 }
1342
1343 void RenderWidgetHostViewAndroid::OnAnimate(base::TimeTicks begin_frame_time) {
1344   if (Animate(begin_frame_time))
1345     SetNeedsAnimate();
1346 }
1347
1348 void RenderWidgetHostViewAndroid::OnLostResources() {
1349   ReleaseLocksOnSurface();
1350   if (layer_.get())
1351     DestroyDelegatedContent();
1352   DCHECK(ack_callbacks_.empty());
1353 }
1354
1355 // static
1356 void
1357 RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResultForDelegatedReadback(
1358     const gfx::Size& dst_size_in_pixel,
1359     const SkBitmap::Config config,
1360     const base::TimeTicks& start_time,
1361     scoped_refptr<cc::Layer> readback_layer,
1362     const base::Callback<void(bool, const SkBitmap&)>& callback,
1363     scoped_ptr<cc::CopyOutputResult> result) {
1364   readback_layer->RemoveFromParent();
1365   PrepareTextureCopyOutputResult(
1366       dst_size_in_pixel, config, start_time, callback, result.Pass());
1367 }
1368
1369 // static
1370 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
1371     const gfx::Size& dst_size_in_pixel,
1372     const SkBitmap::Config bitmap_config,
1373     const base::TimeTicks& start_time,
1374     const base::Callback<void(bool, const SkBitmap&)>& callback,
1375     scoped_ptr<cc::CopyOutputResult> result) {
1376   base::ScopedClosureRunner scoped_callback_runner(
1377       base::Bind(callback, false, SkBitmap()));
1378
1379   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
1380     return;
1381
1382   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
1383   bitmap->setConfig(bitmap_config,
1384                     dst_size_in_pixel.width(),
1385                     dst_size_in_pixel.height(),
1386                     0, kOpaque_SkAlphaType);
1387   if (!bitmap->allocPixels())
1388     return;
1389
1390   ImageTransportFactoryAndroid* factory =
1391       ImageTransportFactoryAndroid::GetInstance();
1392   GLHelper* gl_helper = factory->GetGLHelper();
1393
1394   if (!gl_helper)
1395     return;
1396
1397   scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock(
1398       new SkAutoLockPixels(*bitmap));
1399   uint8* pixels = static_cast<uint8*>(bitmap->getPixels());
1400
1401   cc::TextureMailbox texture_mailbox;
1402   scoped_ptr<cc::SingleReleaseCallback> release_callback;
1403   result->TakeTexture(&texture_mailbox, &release_callback);
1404   DCHECK(texture_mailbox.IsTexture());
1405   if (!texture_mailbox.IsTexture())
1406     return;
1407
1408   ignore_result(scoped_callback_runner.Release());
1409
1410   gl_helper->CropScaleReadbackAndCleanMailbox(
1411       texture_mailbox.mailbox(),
1412       texture_mailbox.sync_point(),
1413       result->size(),
1414       gfx::Rect(result->size()),
1415       dst_size_in_pixel,
1416       pixels,
1417       bitmap_config,
1418       base::Bind(&CopyFromCompositingSurfaceFinished,
1419                  callback,
1420                  base::Passed(&release_callback),
1421                  base::Passed(&bitmap),
1422                  start_time,
1423                  base::Passed(&bitmap_pixels_lock)),
1424       GLHelper::SCALER_QUALITY_GOOD);
1425 }
1426
1427 bool RenderWidgetHostViewAndroid::IsReadbackConfigSupported(
1428     SkBitmap::Config bitmap_config) {
1429   ImageTransportFactoryAndroid* factory =
1430       ImageTransportFactoryAndroid::GetInstance();
1431   GLHelper* gl_helper = factory->GetGLHelper();
1432   if (!gl_helper)
1433     return false;
1434   return gl_helper->IsReadbackConfigSupported(bitmap_config);
1435 }
1436
1437 SkBitmap::Config RenderWidgetHostViewAndroid::PreferredReadbackFormat() {
1438   // Define the criteria here. If say the 16 texture readback is
1439   // supported we should go with that (this degrades quality)
1440   // or stick back to the default format.
1441   if (base::android::SysUtils::IsLowEndDevice()) {
1442     if (IsReadbackConfigSupported(SkBitmap::kRGB_565_Config))
1443       return SkBitmap::kRGB_565_Config;
1444   }
1445   return SkBitmap::kARGB_8888_Config;
1446 }
1447
1448 void RenderWidgetHostViewAndroid::ShowSelectionHandlesAutomatically() {
1449   if (content_view_core_)
1450     content_view_core_->ShowSelectionHandlesAutomatically();
1451 }
1452
1453 void RenderWidgetHostViewAndroid::SelectRange(
1454     float x1, float y1, float x2, float y2) {
1455   if (content_view_core_)
1456     static_cast<WebContentsImpl*>(content_view_core_->GetWebContents())->
1457         SelectRange(gfx::Point(x1, y1), gfx::Point(x2, y2));
1458 }
1459
1460 void RenderWidgetHostViewAndroid::Unselect() {
1461   if (content_view_core_)
1462     content_view_core_->GetWebContents()->Unselect();
1463 }
1464
1465 void RenderWidgetHostViewAndroid::LongPress(
1466     base::TimeTicks time, float x, float y) {
1467   blink::WebGestureEvent long_press = WebGestureEventBuilder::Build(
1468       blink::WebInputEvent::GestureLongPress,
1469       (time - base::TimeTicks()).InSecondsF(), x, y);
1470   SendGestureEvent(long_press);
1471 }
1472
1473 // static
1474 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
1475     blink::WebScreenInfo* results) {
1476   const gfx::Display& display =
1477       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
1478   results->rect = display.bounds();
1479   // TODO(husky): Remove any system controls from availableRect.
1480   results->availableRect = display.work_area();
1481   results->deviceScaleFactor = display.device_scale_factor();
1482   results->orientationAngle = display.RotationAsDegree();
1483   gfx::DeviceDisplayInfo info;
1484   results->depth = info.GetBitsPerPixel();
1485   results->depthPerComponent = info.GetBitsPerComponent();
1486   results->isMonochrome = (results->depthPerComponent == 0);
1487 }
1488
1489 } // namespace content