src/content/renderer/render_widget.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/renderer/render_widget.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "base/bind.h"
   9 #include "base/command_line.h"
  10 #include "base/debug/trace_event.h"
  11 #include "base/debug/trace_event_synthetic_delay.h"
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/singleton.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/stl_util.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/sys_info.h"
  20 #include "build/build_config.h"
  21 #include "cc/base/switches.h"
  22 #include "cc/debug/benchmark_instrumentation.h"
  23 #include "cc/output/output_surface.h"
  24 #include "cc/trees/layer_tree_host.h"
  25 #include "content/child/npapi/webplugin.h"
  26 #include "content/common/gpu/client/context_provider_command_buffer.h"
  27 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
  28 #include "content/common/gpu/gpu_process_launch_causes.h"
  29 #include "content/common/input/synthetic_gesture_packet.h"
  30 #include "content/common/input/web_input_event_traits.h"
  31 #include "content/common/input_messages.h"
  32 #include "content/common/swapped_out_messages.h"
  33 #include "content/common/view_messages.h"
  34 #include "content/public/common/content_switches.h"
  35 #include "content/public/common/context_menu_params.h"
  36 #include "content/renderer/cursor_utils.h"
  37 #include "content/renderer/external_popup_menu.h"
  38 #include "content/renderer/gpu/compositor_output_surface.h"
  39 #include "content/renderer/gpu/compositor_software_output_device.h"
  40 #include "content/renderer/gpu/delegated_compositor_output_surface.h"
  41 #include "content/renderer/gpu/frame_swap_message_queue.h"
  42 #include "content/renderer/gpu/mailbox_output_surface.h"
  43 #include "content/renderer/gpu/queue_message_swap_promise.h"
  44 #include "content/renderer/gpu/render_widget_compositor.h"
  45 #include "content/renderer/ime_event_guard.h"
  46 #include "content/renderer/input/input_handler_manager.h"
  47 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
  48 #include "content/renderer/render_frame_impl.h"
  49 #include "content/renderer/render_frame_proxy.h"
  50 #include "content/renderer/render_process.h"
  51 #include "content/renderer/render_thread_impl.h"
  52 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
  53 #include "content/renderer/resizing_mode_selector.h"
  54 #include "ipc/ipc_sync_message.h"
  55 #include "skia/ext/platform_canvas.h"
  56 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
  57 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
  58 #include "third_party/WebKit/public/platform/WebRect.h"
  59 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
  60 #include "third_party/WebKit/public/platform/WebSize.h"
  61 #include "third_party/WebKit/public/platform/WebString.h"
  62 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
  63 #include "third_party/WebKit/public/web/WebPagePopup.h"
  64 #include "third_party/WebKit/public/web/WebPopupMenu.h"
  65 #include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
  66 #include "third_party/WebKit/public/web/WebRange.h"
  67 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
  68 #include "third_party/skia/include/core/SkShader.h"
  69 #include "ui/base/ui_base_switches.h"
  70 #include "ui/gfx/frame_time.h"
  71 #include "ui/gfx/point_conversions.h"
  72 #include "ui/gfx/rect_conversions.h"
  73 #include "ui/gfx/size_conversions.h"
  74 #include "ui/gfx/skia_util.h"
  75 #include "ui/gl/gl_switches.h"
  76 #include "ui/surface/transport_dib.h"
  77
  78 #if defined(OS_ANDROID)
  79 #include <android/keycodes.h>
  80 #include "content/renderer/android/synchronous_compositor_factory.h"
  81 #endif
  82
  83 #if defined(OS_POSIX)
  84 #include "ipc/ipc_channel_posix.h"
  85 #include "third_party/skia/include/core/SkMallocPixelRef.h"
  86 #include "third_party/skia/include/core/SkPixelRef.h"
  87 #endif  // defined(OS_POSIX)
  88
  89 #include "third_party/WebKit/public/web/WebWidget.h"
  90
  91 using blink::WebCompositionUnderline;
  92 using blink::WebCursorInfo;
  93 using blink::WebDeviceEmulationParams;
  94 using blink::WebGestureEvent;
  95 using blink::WebInputEvent;
  96 using blink::WebKeyboardEvent;
  97 using blink::WebMouseEvent;
  98 using blink::WebMouseWheelEvent;
  99 using blink::WebNavigationPolicy;
 100 using blink::WebPagePopup;
 101 using blink::WebPopupMenu;
 102 using blink::WebPopupMenuInfo;
 103 using blink::WebPopupType;
 104 using blink::WebRange;
 105 using blink::WebRect;
 106 using blink::WebScreenInfo;
 107 using blink::WebSize;
 108 using blink::WebTextDirection;
 109 using blink::WebTouchEvent;
 110 using blink::WebTouchPoint;
 111 using blink::WebVector;
 112 using blink::WebWidget;
 113
 114 namespace {
 115
 116 typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
 117
 118 class TextInputModeMapSingleton {
 119  public:
 120   static TextInputModeMapSingleton* GetInstance() {
 121     return Singleton<TextInputModeMapSingleton>::get();
 122   }
 123   TextInputModeMapSingleton() {
 124     map_["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
 125     map_["latin"] = ui::TEXT_INPUT_MODE_LATIN;
 126     map_["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
 127     map_["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
 128     map_["full-width-latin"] = ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN;
 129     map_["kana"] = ui::TEXT_INPUT_MODE_KANA;
 130     map_["katakana"] = ui::TEXT_INPUT_MODE_KATAKANA;
 131     map_["numeric"] = ui::TEXT_INPUT_MODE_NUMERIC;
 132     map_["tel"] = ui::TEXT_INPUT_MODE_TEL;
 133     map_["email"] = ui::TEXT_INPUT_MODE_EMAIL;
 134     map_["url"] = ui::TEXT_INPUT_MODE_URL;
 135   }
 136   const TextInputModeMap& map() const { return map_; }
 137  private:
 138   TextInputModeMap map_;
 139
 140   friend struct DefaultSingletonTraits<TextInputModeMapSingleton>;
 141
 142   DISALLOW_COPY_AND_ASSIGN(TextInputModeMapSingleton);
 143 };
 144
 145 ui::TextInputMode ConvertInputMode(const blink::WebString& input_mode) {
 146   static TextInputModeMapSingleton* singleton =
 147       TextInputModeMapSingleton::GetInstance();
 148   TextInputModeMap::const_iterator it =
 149       singleton->map().find(input_mode.utf8());
 150   if (it == singleton->map().end())
 151     return ui::TEXT_INPUT_MODE_DEFAULT;
 152   return it->second;
 153 }
 154
 155 bool IsThreadedCompositingEnabled() {
 156   content::RenderThreadImpl* impl = content::RenderThreadImpl::current();
 157   return impl && !!impl->compositor_message_loop_proxy().get();
 158 }
 159
 160 // TODO(brianderson): Replace the hard-coded threshold with a fraction of
 161 // the BeginMainFrame interval.
 162 // 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
 163 // be spent in input hanlders before input starts getting throttled.
 164 const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
 165
 166 }  // namespace
 167
 168 namespace content {
 169
 170 // RenderWidget::ScreenMetricsEmulator ----------------------------------------
 171
 172 class RenderWidget::ScreenMetricsEmulator {
 173  public:
 174   ScreenMetricsEmulator(
 175       RenderWidget* widget,
 176       const WebDeviceEmulationParams& params);
 177   virtual ~ScreenMetricsEmulator();
 178
 179   // Scale and offset used to convert between host coordinates
 180   // and webwidget coordinates.
 181   float scale() { return scale_; }
 182   gfx::Point offset() { return offset_; }
 183   gfx::Rect applied_widget_rect() const { return applied_widget_rect_; }
 184   gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
 185   const WebScreenInfo& original_screen_info() { return original_screen_info_; }
 186
 187   void ChangeEmulationParams(
 188       const WebDeviceEmulationParams& params);
 189
 190   // The following methods alter handlers' behavior for messages related to
 191   // widget size and position.
 192   void OnResizeMessage(const ViewMsg_Resize_Params& params);
 193   void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
 194                                   const gfx::Rect& window_screen_rect);
 195   void OnShowContextMenu(ContextMenuParams* params);
 196   gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
 197
 198  private:
 199   void Reapply();
 200   void Apply(float top_controls_layout_height,
 201              gfx::Rect resizer_rect,
 202              bool is_fullscreen);
 203
 204   RenderWidget* widget_;
 205
 206   // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
 207   WebDeviceEmulationParams params_;
 208
 209   // The computed scale and offset used to fit widget into browser window.
 210   float scale_;
 211   gfx::Point offset_;
 212
 213   // Widget rect as passed to webwidget.
 214   gfx::Rect applied_widget_rect_;
 215
 216   // Original values to restore back after emulation ends.
 217   gfx::Size original_size_;
 218   gfx::Size original_physical_backing_size_;
 219   gfx::Size original_visible_viewport_size_;
 220   blink::WebScreenInfo original_screen_info_;
 221   gfx::Rect original_view_screen_rect_;
 222   gfx::Rect original_window_screen_rect_;
 223 };
 224
 225 RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
 226     RenderWidget* widget,
 227     const WebDeviceEmulationParams& params)
 228     : widget_(widget),
 229       params_(params),
 230       scale_(1.f) {
 231   original_size_ = widget_->size_;
 232   original_physical_backing_size_ = widget_->physical_backing_size_;
 233   original_visible_viewport_size_ = widget_->visible_viewport_size_;
 234   original_screen_info_ = widget_->screen_info_;
 235   original_view_screen_rect_ = widget_->view_screen_rect_;
 236   original_window_screen_rect_ = widget_->window_screen_rect_;
 237   Apply(widget_->top_controls_layout_height_, widget_->resizer_rect_,
 238       widget_->is_fullscreen_);
 239 }
 240
 241 RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
 242   widget_->screen_info_ = original_screen_info_;
 243
 244   widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
 245   widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
 246   widget_->view_screen_rect_ = original_view_screen_rect_;
 247   widget_->window_screen_rect_ = original_window_screen_rect_;
 248   widget_->Resize(original_size_,
 249                   original_physical_backing_size_,
 250                   widget_->top_controls_layout_height_,
 251                   original_visible_viewport_size_,
 252                   widget_->resizer_rect_,
 253                   widget_->is_fullscreen_,
 254                   NO_RESIZE_ACK);
 255 }
 256
 257 void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
 258     const WebDeviceEmulationParams& params) {
 259   params_ = params;
 260   Reapply();
 261 }
 262
 263 void RenderWidget::ScreenMetricsEmulator::Reapply() {
 264   Apply(widget_->top_controls_layout_height_, widget_->resizer_rect_,
 265       widget_->is_fullscreen_);
 266 }
 267
 268 void RenderWidget::ScreenMetricsEmulator::Apply(
 269     float top_controls_layout_height,
 270     gfx::Rect resizer_rect,
 271     bool is_fullscreen) {
 272   applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
 273   if (!applied_widget_rect_.width())
 274     applied_widget_rect_.set_width(original_size_.width());
 275   if (!applied_widget_rect_.height())
 276     applied_widget_rect_.set_height(original_size_.height());
 277
 278   if (params_.fitToView && !original_size_.IsEmpty()) {
 279     int original_width = std::max(original_size_.width(), 1);
 280     int original_height = std::max(original_size_.height(), 1);
 281     float width_ratio =
 282         static_cast<float>(applied_widget_rect_.width()) / original_width;
 283     float height_ratio =
 284         static_cast<float>(applied_widget_rect_.height()) / original_height;
 285     float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
 286     scale_ = 1.f / ratio;
 287
 288     // Center emulated view inside available view space.
 289     offset_.set_x(
 290         (original_size_.width() - scale_ * applied_widget_rect_.width()) / 2);
 291     offset_.set_y(
 292         (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
 293   } else {
 294     scale_ = params_.scale;
 295     offset_.SetPoint(params_.offset.x, params_.offset.y);
 296   }
 297
 298   if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
 299     applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
 300     widget_->screen_info_.rect = original_screen_info_.rect;
 301     widget_->screen_info_.availableRect = original_screen_info_.availableRect;
 302     widget_->window_screen_rect_ = original_window_screen_rect_;
 303   } else {
 304     applied_widget_rect_.set_origin(gfx::Point(0, 0));
 305     widget_->screen_info_.rect = applied_widget_rect_;
 306     widget_->screen_info_.availableRect = applied_widget_rect_;
 307     widget_->window_screen_rect_ = applied_widget_rect_;
 308   }
 309
 310   float applied_device_scale_factor = params_.deviceScaleFactor ?
 311       params_.deviceScaleFactor : original_screen_info_.deviceScaleFactor;
 312   widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
 313
 314   // Pass three emulation parameters to the blink side:
 315   // - we keep the real device scale factor in compositor to produce sharp image
 316   //   even when emulating different scale factor;
 317   // - in order to fit into view, WebView applies offset and scale to the
 318   //   root layer.
 319   widget_->SetScreenMetricsEmulationParameters(
 320       original_screen_info_.deviceScaleFactor, offset_, scale_);
 321
 322   widget_->SetDeviceScaleFactor(applied_device_scale_factor);
 323   widget_->view_screen_rect_ = applied_widget_rect_;
 324
 325   gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
 326       original_size_, original_screen_info_.deviceScaleFactor));
 327   widget_->Resize(applied_widget_rect_.size(), physical_backing_size,
 328       top_controls_layout_height, applied_widget_rect_.size(), resizer_rect,
 329       is_fullscreen, NO_RESIZE_ACK);
 330 }
 331
 332 void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
 333     const ViewMsg_Resize_Params& params) {
 334   bool need_ack = params.new_size != original_size_ &&
 335       !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
 336   original_size_ = params.new_size;
 337   original_physical_backing_size_ = params.physical_backing_size;
 338   original_screen_info_ = params.screen_info;
 339   original_visible_viewport_size_ = params.visible_viewport_size;
 340   Apply(params.top_controls_layout_height, params.resizer_rect,
 341       params.is_fullscreen);
 342
 343   if (need_ack) {
 344     widget_->set_next_paint_is_resize_ack();
 345     if (widget_->compositor_)
 346       widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
 347   }
 348 }
 349
 350 void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
 351     const gfx::Rect& view_screen_rect,
 352     const gfx::Rect& window_screen_rect) {
 353   original_view_screen_rect_ = view_screen_rect;
 354   original_window_screen_rect_ = window_screen_rect;
 355   if (params_.screenPosition == WebDeviceEmulationParams::Desktop)
 356     Reapply();
 357 }
 358
 359 void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
 360     ContextMenuParams* params) {
 361   params->x *= scale_;
 362   params->x += offset_.x();
 363   params->y *= scale_;
 364   params->y += offset_.y();
 365 }
 366
 367 gfx::Rect RenderWidget::ScreenMetricsEmulator::AdjustValidationMessageAnchor(
 368     const gfx::Rect& anchor) {
 369   gfx::Rect scaled = gfx::ToEnclosedRect(gfx::ScaleRect(anchor, scale_));
 370   scaled.set_x(scaled.x() + offset_.x());
 371   scaled.set_y(scaled.y() + offset_.y());
 372   return scaled;
 373 }
 374
 375 // RenderWidget ---------------------------------------------------------------
 376
 377 RenderWidget::RenderWidget(blink::WebPopupType popup_type,
 378                            const blink::WebScreenInfo& screen_info,
 379                            bool swapped_out,
 380                            bool hidden,
 381                            bool never_visible)
 382     : routing_id_(MSG_ROUTING_NONE),
 383       surface_id_(0),
 384       webwidget_(NULL),
 385       opener_id_(MSG_ROUTING_NONE),
 386       init_complete_(false),
 387       top_controls_layout_height_(0.f),
 388       next_paint_flags_(0),
 389       auto_resize_mode_(false),
 390       need_update_rect_for_auto_resize_(false),
 391       did_show_(false),
 392       is_hidden_(hidden),
 393       never_visible_(never_visible),
 394       is_fullscreen_(false),
 395       has_focus_(false),
 396       handling_input_event_(false),
 397       handling_ime_event_(false),
 398       handling_event_type_(WebInputEvent::Undefined),
 399       ignore_ack_for_mouse_move_from_debugger_(false),
 400       closing_(false),
 401       host_closing_(false),
 402       is_swapped_out_(swapped_out),
 403       input_method_is_active_(false),
 404       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
 405       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
 406       can_compose_inline_(true),
 407       popup_type_(popup_type),
 408       pending_window_rect_count_(0),
 409       suppress_next_char_events_(false),
 410       screen_info_(screen_info),
 411       device_scale_factor_(screen_info_.deviceScaleFactor),
 412       current_event_latency_info_(NULL),
 413       next_output_surface_id_(0),
 414 #if defined(OS_ANDROID)
 415       text_field_is_dirty_(false),
 416       outstanding_ime_acks_(0),
 417       body_background_color_(SK_ColorWHITE),
 418 #endif
 419       popup_origin_scale_for_emulation_(0.f),
 420       frame_swap_message_queue_(new FrameSwapMessageQueue()),
 421       resizing_mode_selector_(new ResizingModeSelector()),
 422       context_menu_source_type_(ui::MENU_SOURCE_MOUSE),
 423       has_host_context_menu_location_(false) {
 424   if (!swapped_out)
 425     RenderProcess::current()->AddRefProcess();
 426   DCHECK(RenderThread::Get());
 427   device_color_profile_.push_back('0');
 428 }
 429
 430 RenderWidget::~RenderWidget() {
 431   DCHECK(!webwidget_) << "Leaking our WebWidget!";
 432
 433   // If we are swapped out, we have released already.
 434   if (!is_swapped_out_ && RenderProcess::current())
 435     RenderProcess::current()->ReleaseProcess();
 436 }
 437
 438 // static
 439 RenderWidget* RenderWidget::Create(int32 opener_id,
 440                                    blink::WebPopupType popup_type,
 441                                    const blink::WebScreenInfo& screen_info) {
 442   DCHECK(opener_id != MSG_ROUTING_NONE);
 443   scoped_refptr<RenderWidget> widget(
 444       new RenderWidget(popup_type, screen_info, false, false, false));
 445   if (widget->Init(opener_id)) {  // adds reference on success.
 446     return widget.get();
 447   }
 448   return NULL;
 449 }
 450
 451 // static
 452 WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
 453   switch (render_widget->popup_type_) {
 454     case blink::WebPopupTypeNone:  // Nothing to create.
 455       break;
 456     case blink::WebPopupTypeSelect:
 457     case blink::WebPopupTypeSuggestion:
 458       return WebPopupMenu::create(render_widget);
 459     case blink::WebPopupTypePage:
 460       return WebPagePopup::create(render_widget);
 461     default:
 462       NOTREACHED();
 463   }
 464   return NULL;
 465 }
 466
 467 bool RenderWidget::Init(int32 opener_id) {
 468   return DoInit(opener_id,
 469                 RenderWidget::CreateWebWidget(this),
 470                 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
 471                                              &routing_id_, &surface_id_));
 472 }
 473
 474 bool RenderWidget::DoInit(int32 opener_id,
 475                           WebWidget* web_widget,
 476                           IPC::SyncMessage* create_widget_message) {
 477   DCHECK(!webwidget_);
 478
 479   if (opener_id != MSG_ROUTING_NONE)
 480     opener_id_ = opener_id;
 481
 482   webwidget_ = web_widget;
 483
 484   bool result = RenderThread::Get()->Send(create_widget_message);
 485   if (result) {
 486     RenderThread::Get()->AddRoute(routing_id_, this);
 487     // Take a reference on behalf of the RenderThread.  This will be balanced
 488     // when we receive ViewMsg_Close.
 489     AddRef();
 490     if (RenderThreadImpl::current()) {
 491       RenderThreadImpl::current()->WidgetCreated();
 492       if (is_hidden_)
 493         RenderThreadImpl::current()->WidgetHidden();
 494     }
 495     return true;
 496   } else {
 497     // The above Send can fail when the tab is closing.
 498     return false;
 499   }
 500 }
 501
 502 // This is used to complete pending inits and non-pending inits.
 503 void RenderWidget::CompleteInit() {
 504   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 505
 506   init_complete_ = true;
 507
 508   if (compositor_)
 509     StartCompositor();
 510
 511   Send(new ViewHostMsg_RenderViewReady(routing_id_));
 512 }
 513
 514 void RenderWidget::SetSwappedOut(bool is_swapped_out) {
 515   // We should only toggle between states.
 516   DCHECK(is_swapped_out_ != is_swapped_out);
 517   is_swapped_out_ = is_swapped_out;
 518
 519   // If we are swapping out, we will call ReleaseProcess, allowing the process
 520   // to exit if all of its RenderViews are swapped out.  We wait until the
 521   // WasSwappedOut call to do this, to allow the unload handler to finish.
 522   // If we are swapping in, we call AddRefProcess to prevent the process from
 523   // exiting.
 524   if (!is_swapped_out_)
 525     RenderProcess::current()->AddRefProcess();
 526 }
 527
 528 void RenderWidget::WasSwappedOut() {
 529   // If we have been swapped out and no one else is using this process,
 530   // it's safe to exit now.
 531   CHECK(is_swapped_out_);
 532   RenderProcess::current()->ReleaseProcess();
 533 }
 534
 535 void RenderWidget::EnableScreenMetricsEmulation(
 536     const WebDeviceEmulationParams& params) {
 537   if (!screen_metrics_emulator_)
 538     screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
 539   else
 540     screen_metrics_emulator_->ChangeEmulationParams(params);
 541 }
 542
 543 void RenderWidget::DisableScreenMetricsEmulation() {
 544   screen_metrics_emulator_.reset();
 545 }
 546
 547 void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
 548     ScreenMetricsEmulator* emulator) {
 549   popup_origin_scale_for_emulation_ = emulator->scale();
 550   popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
 551   popup_screen_origin_for_emulation_ = gfx::Point(
 552       emulator->original_screen_rect().origin().x() + emulator->offset().x(),
 553       emulator->original_screen_rect().origin().y() + emulator->offset().y());
 554   screen_info_ = emulator->original_screen_info();
 555   device_scale_factor_ = screen_info_.deviceScaleFactor;
 556 }
 557
 558 gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
 559   if (screen_metrics_emulator_)
 560     return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
 561   return anchor;
 562 }
 563
 564 void RenderWidget::SetScreenMetricsEmulationParameters(
 565     float device_scale_factor,
 566     const gfx::Point& root_layer_offset,
 567     float root_layer_scale) {
 568   // This is only supported in RenderView.
 569   NOTREACHED();
 570 }
 571
 572 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 573 void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
 574     ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
 575   popup->SetOriginScaleAndOffsetForEmulation(
 576       emulator->scale(), emulator->offset());
 577 }
 578 #endif
 579
 580 void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
 581   if (screen_metrics_emulator_)
 582     screen_metrics_emulator_->OnShowContextMenu(params);
 583 }
 584
 585 void RenderWidget::ScheduleCompositeWithForcedRedraw() {
 586   if (compositor_) {
 587     // Regardless of whether threaded compositing is enabled, always
 588     // use this mechanism to force the compositor to redraw. However,
 589     // the invalidation code path below is still needed for the
 590     // non-threaded case.
 591     compositor_->SetNeedsForcedRedraw();
 592   }
 593   scheduleComposite();
 594 }
 595
 596 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
 597   bool handled = true;
 598   IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
 599     IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
 600     IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
 601                         OnCursorVisibilityChange)
 602     IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
 603     IPC_MESSAGE_HANDLER(InputMsg_ImeConfirmComposition, OnImeConfirmComposition)
 604     IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
 605     IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
 606     IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
 607                         OnSyntheticGestureCompleted)
 608     IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
 609     IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
 610     IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
 611     IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
 612     IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
 613     IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
 614     IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
 615     IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowShown, OnCandidateWindowShown)
 616     IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowUpdated,
 617                         OnCandidateWindowUpdated)
 618     IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowHidden, OnCandidateWindowHidden)
 619     IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
 620     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
 621     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
 622     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
 623 #if defined(OS_ANDROID)
 624     IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
 625     IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
 626 #endif
 627     IPC_MESSAGE_UNHANDLED(handled = false)
 628   IPC_END_MESSAGE_MAP()
 629   return handled;
 630 }
 631
 632 bool RenderWidget::Send(IPC::Message* message) {
 633   // Don't send any messages after the browser has told us to close, and filter
 634   // most outgoing messages while swapped out.
 635   if ((is_swapped_out_ &&
 636        !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
 637       closing_) {
 638     delete message;
 639     return false;
 640   }
 641
 642   // If given a messsage without a routing ID, then assign our routing ID.
 643   if (message->routing_id() == MSG_ROUTING_NONE)
 644     message->set_routing_id(routing_id_);
 645
 646   return RenderThread::Get()->Send(message);
 647 }
 648
 649 void RenderWidget::Resize(const gfx::Size& new_size,
 650                           const gfx::Size& physical_backing_size,
 651                           float top_controls_layout_height,
 652                           const gfx::Size& visible_viewport_size,
 653                           const gfx::Rect& resizer_rect,
 654                           bool is_fullscreen,
 655                           ResizeAck resize_ack) {
 656   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
 657     // A resize ack shouldn't be requested if we have not ACK'd the previous
 658     // one.
 659     DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
 660     DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
 661   }
 662
 663   // Ignore this during shutdown.
 664   if (!webwidget_)
 665     return;
 666
 667   if (compositor_) {
 668     compositor_->setViewportSize(new_size, physical_backing_size);
 669     compositor_->SetTopControlsLayoutHeight(top_controls_layout_height);
 670   }
 671
 672   physical_backing_size_ = physical_backing_size;
 673   top_controls_layout_height_ = top_controls_layout_height;
 674   visible_viewport_size_ = visible_viewport_size;
 675   resizer_rect_ = resizer_rect;
 676
 677   // NOTE: We may have entered fullscreen mode without changing our size.
 678   bool fullscreen_change = is_fullscreen_ != is_fullscreen;
 679   if (fullscreen_change)
 680     WillToggleFullscreen();
 681   is_fullscreen_ = is_fullscreen;
 682
 683   if (size_ != new_size) {
 684     size_ = new_size;
 685
 686     // When resizing, we want to wait to paint before ACK'ing the resize.  This
 687     // ensures that we only resize as fast as we can paint.  We only need to
 688     // send an ACK if we are resized to a non-empty rect.
 689     webwidget_->resize(new_size);
 690   } else if (!resizing_mode_selector_->is_synchronous_mode()) {
 691     resize_ack = NO_RESIZE_ACK;
 692   }
 693
 694   webwidget()->resizePinchViewport(gfx::Size(
 695       visible_viewport_size.width(),
 696       visible_viewport_size.height()));
 697
 698   if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
 699     // For empty size or empty physical_backing_size, there is no next paint
 700     // (along with which to send the ack) until they are set to non-empty.
 701     resize_ack = NO_RESIZE_ACK;
 702   }
 703
 704   // Send the Resize_ACK flag once we paint again if requested.
 705   if (resize_ack == SEND_RESIZE_ACK)
 706     set_next_paint_is_resize_ack();
 707
 708   if (fullscreen_change)
 709     DidToggleFullscreen();
 710
 711   // If a resize ack is requested and it isn't set-up, then no more resizes will
 712   // come in and in general things will go wrong.
 713   DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
 714 }
 715
 716 void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
 717   Resize(new_position.size(),
 718          new_position.size(),
 719          top_controls_layout_height_,
 720          visible_viewport_size_,
 721          gfx::Rect(),
 722          is_fullscreen_,
 723          NO_RESIZE_ACK);
 724   view_screen_rect_ = new_position;
 725   window_screen_rect_ = new_position;
 726   if (!did_show_)
 727     initial_pos_ = new_position;
 728 }
 729
 730 void RenderWidget::OnClose() {
 731   if (closing_)
 732     return;
 733   closing_ = true;
 734
 735   // Browser correspondence is no longer needed at this point.
 736   if (routing_id_ != MSG_ROUTING_NONE) {
 737     if (RenderThreadImpl::current())
 738       RenderThreadImpl::current()->WidgetDestroyed();
 739     RenderThread::Get()->RemoveRoute(routing_id_);
 740     SetHidden(false);
 741   }
 742
 743   // If there is a Send call on the stack, then it could be dangerous to close
 744   // now.  Post a task that only gets invoked when there are no nested message
 745   // loops.
 746   base::MessageLoop::current()->PostNonNestableTask(
 747       FROM_HERE, base::Bind(&RenderWidget::Close, this));
 748
 749   // Balances the AddRef taken when we called AddRoute.
 750   Release();
 751 }
 752
 753 // Got a response from the browser after the renderer decided to create a new
 754 // view.
 755 void RenderWidget::OnCreatingNewAck() {
 756   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 757
 758   CompleteInit();
 759 }
 760
 761 void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
 762   if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
 763     return;
 764
 765   if (screen_metrics_emulator_) {
 766     screen_metrics_emulator_->OnResizeMessage(params);
 767     return;
 768   }
 769
 770   bool orientation_changed =
 771       screen_info_.orientationAngle != params.screen_info.orientationAngle;
 772
 773   screen_info_ = params.screen_info;
 774   SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
 775   Resize(params.new_size, params.physical_backing_size,
 776          params.top_controls_layout_height,
 777          params.visible_viewport_size, params.resizer_rect,
 778          params.is_fullscreen, SEND_RESIZE_ACK);
 779
 780   if (orientation_changed)
 781     OnOrientationChange();
 782 }
 783
 784 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
 785   if (resizer_rect_ == resizer_rect)
 786     return;
 787   resizer_rect_ = resizer_rect;
 788   if (webwidget_)
 789     webwidget_->didChangeWindowResizerRect();
 790 }
 791
 792 void RenderWidget::OnWasHidden() {
 793   TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
 794   // Go into a mode where we stop generating paint and scrolling events.
 795   SetHidden(true);
 796   FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
 797                     WasHidden());
 798 }
 799
 800 void RenderWidget::OnWasShown(bool needs_repainting,
 801                               const ui::LatencyInfo& latency_info) {
 802   TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
 803   // During shutdown we can just ignore this message.
 804   if (!webwidget_)
 805     return;
 806
 807   // See OnWasHidden
 808   SetHidden(false);
 809   FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
 810                     WasShown());
 811
 812   if (!needs_repainting)
 813     return;
 814
 815   // Generate a full repaint.
 816   if (compositor_) {
 817     ui::LatencyInfo swap_latency_info(latency_info);
 818     scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
 819         compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
 820     compositor_->SetNeedsForcedRedraw();
 821   }
 822   scheduleComposite();
 823 }
 824
 825 void RenderWidget::OnRequestMoveAck() {
 826   DCHECK(pending_window_rect_count_);
 827   pending_window_rect_count_--;
 828 }
 829
 830 GURL RenderWidget::GetURLForGraphicsContext3D() {
 831   return GURL();
 832 }
 833
 834 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
 835   // For widgets that are never visible, we don't start the compositor, so we
 836   // never get a request for a cc::OutputSurface.
 837   DCHECK(!never_visible_);
 838
 839 #if defined(OS_ANDROID)
 840   if (SynchronousCompositorFactory* factory =
 841       SynchronousCompositorFactory::GetInstance()) {
 842     return factory->CreateOutputSurface(routing_id(),
 843                                         frame_swap_message_queue_);
 844   }
 845 #endif
 846
 847   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 848   bool use_software = fallback;
 849   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
 850     use_software = true;
 851
 852   scoped_refptr<ContextProviderCommandBuffer> context_provider;
 853   if (!use_software) {
 854     context_provider = ContextProviderCommandBuffer::Create(
 855         CreateGraphicsContext3D(), "RenderCompositor");
 856     if (!context_provider.get()) {
 857       // Cause the compositor to wait and try again.
 858       return scoped_ptr<cc::OutputSurface>();
 859     }
 860   }
 861
 862   uint32 output_surface_id = next_output_surface_id_++;
 863   if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
 864     DCHECK(IsThreadedCompositingEnabled());
 865     return scoped_ptr<cc::OutputSurface>(
 866         new DelegatedCompositorOutputSurface(routing_id(),
 867                                              output_surface_id,
 868                                              context_provider,
 869                                              frame_swap_message_queue_));
 870   }
 871   if (!context_provider.get()) {
 872     scoped_ptr<cc::SoftwareOutputDevice> software_device(
 873         new CompositorSoftwareOutputDevice());
 874
 875     return scoped_ptr<cc::OutputSurface>(
 876         new CompositorOutputSurface(routing_id(),
 877                                     output_surface_id,
 878                                     NULL,
 879                                     software_device.Pass(),
 880                                     frame_swap_message_queue_,
 881                                     true));
 882   }
 883
 884   if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
 885     // Composite-to-mailbox is currently used for layout tests in order to cause
 886     // them to draw inside in the renderer to do the readback there. This should
 887     // no longer be the case when crbug.com/311404 is fixed.
 888     DCHECK(IsThreadedCompositingEnabled() ||
 889            RenderThreadImpl::current()->layout_test_mode());
 890     cc::ResourceFormat format = cc::RGBA_8888;
 891     if (base::SysInfo::IsLowEndDevice())
 892       format = cc::RGB_565;
 893     return scoped_ptr<cc::OutputSurface>(
 894         new MailboxOutputSurface(routing_id(),
 895                                  output_surface_id,
 896                                  context_provider,
 897                                  scoped_ptr<cc::SoftwareOutputDevice>(),
 898                                  frame_swap_message_queue_,
 899                                  format));
 900   }
 901   bool use_swap_compositor_frame_message = false;
 902   return scoped_ptr<cc::OutputSurface>(
 903       new CompositorOutputSurface(routing_id(),
 904                                   output_surface_id,
 905                                   context_provider,
 906                                   scoped_ptr<cc::SoftwareOutputDevice>(),
 907                                   frame_swap_message_queue_,
 908                                   use_swap_compositor_frame_message));
 909 }
 910
 911 void RenderWidget::OnSwapBuffersAborted() {
 912   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
 913   // Schedule another frame so the compositor learns about it.
 914   scheduleComposite();
 915 }
 916
 917 void RenderWidget::OnSwapBuffersPosted() {
 918   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 919 }
 920
 921 void RenderWidget::OnSwapBuffersComplete() {
 922   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
 923
 924   // Notify subclasses that composited rendering was flushed to the screen.
 925   DidFlushPaint();
 926 }
 927
 928 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
 929                                       const ui::LatencyInfo& latency_info,
 930                                       bool is_keyboard_shortcut) {
 931   base::AutoReset<bool> handling_input_event_resetter(
 932       &handling_input_event_, true);
 933   if (!input_event)
 934     return;
 935   base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
 936       &handling_event_type_, input_event->type);
 937 #if defined(OS_ANDROID)
 938   // On Android, when a key is pressed or sent from the Keyboard using IME,
 939   // |AdapterInputConnection| generates input key events to make sure all JS
 940   // listeners that monitor KeyUp and KeyDown events receive the proper key
 941   // code. Since this input key event comes from IME, we need to set the
 942   // IME event guard here to make sure it does not interfere with other IME
 943   // events.
 944   scoped_ptr<ImeEventGuard> ime_event_guard_maybe;
 945   if (WebInputEvent::isKeyboardEventType(input_event->type)) {
 946     const WebKeyboardEvent& key_event =
 947         *static_cast<const WebKeyboardEvent*>(input_event);
 948     // Some keys are special and it's essential that no events get blocked.
 949     if (key_event.nativeKeyCode != AKEYCODE_TAB)
 950       ime_event_guard_maybe.reset(new ImeEventGuard(this));
 951   }
 952 #endif
 953
 954   base::AutoReset<const ui::LatencyInfo*> resetter(&current_event_latency_info_,
 955                                                    &latency_info);
 956
 957   base::TimeTicks start_time;
 958   if (base::TimeTicks::IsHighResNowFastAndReliable())
 959     start_time = base::TimeTicks::HighResNow();
 960
 961   const char* const event_name =
 962       WebInputEventTraits::GetName(input_event->type);
 963   TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
 964                "event", event_name);
 965   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
 966   TRACE_EVENT_FLOW_STEP0(
 967       "input",
 968       "LatencyInfo.Flow",
 969       TRACE_ID_DONT_MANGLE(latency_info.trace_id),
 970       "HanldeInputEventMain");
 971
 972   scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
 973   ui::LatencyInfo swap_latency_info(latency_info);
 974   if (compositor_) {
 975     latency_info_swap_promise_monitor =
 976         compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
 977             .Pass();
 978   }
 979
 980   if (base::TimeTicks::IsHighResNowFastAndReliable()) {
 981     // If we don't have a high res timer, these metrics won't be accurate enough
 982     // to be worth collecting. Note that this does introduce some sampling bias.
 983
 984     base::TimeDelta now = base::TimeDelta::FromInternalValue(
 985         base::TimeTicks::HighResNow().ToInternalValue());
 986
 987     int64 delta =
 988         static_cast<int64>((now.InSecondsF() - input_event->timeStampSeconds) *
 989                            base::Time::kMicrosecondsPerSecond);
 990
 991     UMA_HISTOGRAM_CUSTOM_COUNTS(
 992         "Event.AggregatedLatency.Renderer2", delta, 1, 10000000, 100);
 993     base::HistogramBase* counter_for_type = base::Histogram::FactoryGet(
 994         base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
 995         1,
 996         10000000,
 997         100,
 998         base::HistogramBase::kUmaTargetedHistogramFlag);
 999     counter_for_type->Add(delta);
1000   }
1001
1002   bool prevent_default = false;
1003   if (WebInputEvent::isMouseEventType(input_event->type)) {
1004     const WebMouseEvent& mouse_event =
1005         *static_cast<const WebMouseEvent*>(input_event);
1006     TRACE_EVENT2("renderer", "HandleMouseMove",
1007                  "x", mouse_event.x, "y", mouse_event.y);
1008     context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
1009     prevent_default = WillHandleMouseEvent(mouse_event);
1010   }
1011
1012   if (WebInputEvent::isKeyboardEventType(input_event->type)) {
1013     context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
1014 #if defined(OS_ANDROID)
1015     // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
1016     // case it should behave like a select key (i.e. causing a click if a button
1017     // is focused). However, if a text field is focused (2), its intended
1018     // behavior is to just show the IME and don't propagate the key.
1019     // A typical use case is a web form: the DPAD_CENTER should bring up the IME
1020     // when clicked on an input text field and cause the form submit if clicked
1021     // when the submit button is focused, but not vice-versa.
1022     // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
1023     // but at this point we have to swallow the event for the scenario (2).
1024     const WebKeyboardEvent& key_event =
1025         *static_cast<const WebKeyboardEvent*>(input_event);
1026     if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
1027         GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
1028       OnShowImeIfNeeded();
1029       prevent_default = true;
1030     }
1031 #endif
1032   }
1033
1034   if (WebInputEvent::isGestureEventType(input_event->type)) {
1035     const WebGestureEvent& gesture_event =
1036         *static_cast<const WebGestureEvent*>(input_event);
1037     context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
1038     prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1039   }
1040
1041   bool processed = prevent_default;
1042   if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1043     suppress_next_char_events_ = false;
1044     if (!processed && webwidget_)
1045       processed = webwidget_->handleInputEvent(*input_event);
1046   }
1047
1048   // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1049   // it's not processed by webkit, then we need to suppress the upcoming Char
1050   // events.
1051   if (!processed && is_keyboard_shortcut)
1052     suppress_next_char_events_ = true;
1053
1054   InputEventAckState ack_result = processed ?
1055       INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1056   if (!processed &&  input_event->type == WebInputEvent::TouchStart) {
1057     const WebTouchEvent& touch_event =
1058         *static_cast<const WebTouchEvent*>(input_event);
1059     // Hit-test for all the pressed touch points. If there is a touch-handler
1060     // for any of the touch points, then the renderer should continue to receive
1061     // touch events.
1062     ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1063     for (size_t i = 0; i < touch_event.touchesLength; ++i) {
1064       if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
1065           HasTouchEventHandlersAt(
1066               gfx::ToFlooredPoint(touch_event.touches[i].position))) {
1067         ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1068         break;
1069       }
1070     }
1071   }
1072
1073   // Unconsumed touchmove acks should never be throttled as they're required to
1074   // dispatch compositor-handled scroll gestures.
1075   bool event_type_can_be_rate_limited =
1076       input_event->type == WebInputEvent::MouseMove ||
1077       input_event->type == WebInputEvent::MouseWheel ||
1078       (input_event->type == WebInputEvent::TouchMove &&
1079        ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
1080
1081   bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
1082
1083   // If we don't have a fast and accurate HighResNow, we assume the input
1084   // handlers are heavy and rate limit them.
1085   bool rate_limiting_wanted = true;
1086   if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1087       base::TimeTicks end_time = base::TimeTicks::HighResNow();
1088       total_input_handling_time_this_frame_ += (end_time - start_time);
1089       rate_limiting_wanted =
1090           total_input_handling_time_this_frame_.InMicroseconds() >
1091           kInputHandlingTimeThrottlingThresholdMicroseconds;
1092   }
1093
1094   TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
1095
1096   // Note that we can't use handling_event_type_ here since it will be overriden
1097   // by reentrant calls for events after the paused one.
1098   bool no_ack = ignore_ack_for_mouse_move_from_debugger_ &&
1099       input_event->type == WebInputEvent::MouseMove;
1100   if (!WebInputEventTraits::IgnoresAckDisposition(*input_event) && !no_ack) {
1101     InputHostMsg_HandleInputEvent_ACK_Params ack;
1102     ack.type = input_event->type;
1103     ack.state = ack_result;
1104     ack.latency = swap_latency_info;
1105     scoped_ptr<IPC::Message> response(
1106         new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
1107     if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1108         frame_pending && !is_hidden_) {
1109       // We want to rate limit the input events in this case, so we'll wait for
1110       // painting to finish before ACKing this message.
1111       TRACE_EVENT_INSTANT0("renderer",
1112         "RenderWidget::OnHandleInputEvent ack throttled",
1113         TRACE_EVENT_SCOPE_THREAD);
1114       if (pending_input_event_ack_) {
1115         // As two different kinds of events could cause us to postpone an ack
1116         // we send it now, if we have one pending. The Browser should never
1117         // send us the same kind of event we are delaying the ack for.
1118         Send(pending_input_event_ack_.release());
1119       }
1120       pending_input_event_ack_ = response.Pass();
1121       if (compositor_)
1122         compositor_->NotifyInputThrottledUntilCommit();
1123     } else {
1124       Send(response.release());
1125     }
1126   }
1127   if (input_event->type == WebInputEvent::MouseMove)
1128     ignore_ack_for_mouse_move_from_debugger_ = false;
1129
1130 #if defined(OS_ANDROID)
1131   // Allow the IME to be shown when the focus changes as a consequence
1132   // of a processed touch end event.
1133   if (input_event->type == WebInputEvent::TouchEnd && processed)
1134     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
1135 #elif defined(USE_AURA)
1136   // Show the virtual keyboard if enabled and a user gesture triggers a focus
1137   // change.
1138   if (processed && (input_event->type == WebInputEvent::TouchEnd ||
1139       input_event->type == WebInputEvent::MouseUp))
1140     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
1141 #endif
1142
1143   if (!prevent_default) {
1144     if (WebInputEvent::isKeyboardEventType(input_event->type))
1145       DidHandleKeyEvent();
1146     if (WebInputEvent::isMouseEventType(input_event->type))
1147       DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
1148     if (WebInputEvent::isTouchEventType(input_event->type))
1149       DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
1150   }
1151 }
1152
1153 void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1154   if (webwidget_)
1155     webwidget_->setCursorVisibilityState(is_visible);
1156 }
1157
1158 void RenderWidget::OnMouseCaptureLost() {
1159   if (webwidget_)
1160     webwidget_->mouseCaptureLost();
1161 }
1162
1163 void RenderWidget::OnSetFocus(bool enable) {
1164   has_focus_ = enable;
1165   if (webwidget_)
1166     webwidget_->setFocus(enable);
1167 }
1168
1169 void RenderWidget::ClearFocus() {
1170   // We may have got the focus from the browser before this gets processed, in
1171   // which case we do not want to unfocus ourself.
1172   if (!has_focus_ && webwidget_)
1173     webwidget_->setFocus(false);
1174 }
1175
1176 void RenderWidget::FlushPendingInputEventAck() {
1177   if (pending_input_event_ack_)
1178     Send(pending_input_event_ack_.release());
1179   total_input_handling_time_this_frame_ = base::TimeDelta();
1180 }
1181
1182 ///////////////////////////////////////////////////////////////////////////////
1183 // WebWidgetClient
1184
1185 void RenderWidget::didAutoResize(const WebSize& new_size) {
1186   if (size_.width() != new_size.width || size_.height() != new_size.height) {
1187     size_ = new_size;
1188
1189     if (resizing_mode_selector_->is_synchronous_mode()) {
1190       WebRect new_pos(rootWindowRect().x,
1191                       rootWindowRect().y,
1192                       new_size.width,
1193                       new_size.height);
1194       view_screen_rect_ = new_pos;
1195       window_screen_rect_ = new_pos;
1196     }
1197
1198     AutoResizeCompositor();
1199
1200     if (!resizing_mode_selector_->is_synchronous_mode())
1201       need_update_rect_for_auto_resize_ = true;
1202   }
1203 }
1204
1205 void RenderWidget::AutoResizeCompositor()  {
1206   physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1207       device_scale_factor_));
1208   if (compositor_)
1209     compositor_->setViewportSize(size_, physical_backing_size_);
1210 }
1211
1212 void RenderWidget::initializeLayerTreeView() {
1213   DCHECK(!host_closing_);
1214
1215   compositor_ =
1216       RenderWidgetCompositor::Create(this, IsThreadedCompositingEnabled());
1217   compositor_->setViewportSize(size_, physical_backing_size_);
1218   if (init_complete_)
1219     StartCompositor();
1220 }
1221
1222 void RenderWidget::DestroyLayerTreeView() {
1223   // Always send this notification to prevent new layer tree views from
1224   // being created, even if one hasn't been created yet.
1225   if (webwidget_)
1226     webwidget_->willCloseLayerTreeView();
1227   compositor_.reset();
1228 }
1229
1230 blink::WebLayerTreeView* RenderWidget::layerTreeView() {
1231   return compositor_.get();
1232 }
1233
1234 void RenderWidget::willBeginCompositorFrame() {
1235   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1236
1237   // The following two can result in further layout and possibly
1238   // enable GPU acceleration so they need to be called before any painting
1239   // is done.
1240   UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
1241   UpdateSelectionBounds();
1242 }
1243
1244 void RenderWidget::didBecomeReadyForAdditionalInput() {
1245   TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
1246   FlushPendingInputEventAck();
1247 }
1248
1249 void RenderWidget::DidCommitCompositorFrame() {
1250   FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
1251                     DidCommitCompositorFrame());
1252 #if defined(VIDEO_HOLE)
1253   FOR_EACH_OBSERVER(RenderFrameImpl, video_hole_frames_,
1254                     DidCommitCompositorFrame());
1255 #endif  // defined(VIDEO_HOLE)
1256 }
1257
1258 // static
1259 scoped_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
1260     IPC::Message* msg,
1261     MessageDeliveryPolicy policy,
1262     FrameSwapMessageQueue* frame_swap_message_queue,
1263     scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
1264     bool commit_requested,
1265     int source_frame_number) {
1266   if (policy == MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE &&
1267       // No need for lock: this gets changed only on this thread.
1268       !commit_requested &&
1269       // No need for lock: Messages are only enqueued from this thread, if we
1270       // don't have any now, no other thread will add any.
1271       frame_swap_message_queue->Empty()) {
1272     sync_message_filter->Send(msg);
1273     return scoped_ptr<cc::SwapPromise>();
1274   }
1275
1276   bool first_message_for_frame = false;
1277   frame_swap_message_queue->QueueMessageForFrame(policy,
1278                                                  source_frame_number,
1279                                                  make_scoped_ptr(msg),
1280                                                  &first_message_for_frame);
1281   if (first_message_for_frame) {
1282     scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
1283         sync_message_filter, frame_swap_message_queue, source_frame_number));
1284     return promise.PassAs<cc::SwapPromise>();
1285   }
1286   return scoped_ptr<cc::SwapPromise>();
1287 }
1288
1289 void RenderWidget::QueueMessage(IPC::Message* msg,
1290                                 MessageDeliveryPolicy policy) {
1291   // RenderThreadImpl::current() is NULL in some tests.
1292   if (!compositor_ || !RenderThreadImpl::current()) {
1293     Send(msg);
1294     return;
1295   }
1296
1297   scoped_ptr<cc::SwapPromise> swap_promise =
1298       QueueMessageImpl(msg,
1299                        policy,
1300                        frame_swap_message_queue_.get(),
1301                        RenderThreadImpl::current()->sync_message_filter(),
1302                        compositor_->commitRequested(),
1303                        compositor_->GetSourceFrameNumber());
1304
1305   if (swap_promise) {
1306     compositor_->QueueSwapPromise(swap_promise.Pass());
1307     compositor_->SetNeedsCommit();
1308   }
1309 }
1310
1311 void RenderWidget::didCommitAndDrawCompositorFrame() {
1312   // NOTE: Tests may break if this event is renamed or moved. See
1313   // tab_capture_performancetest.cc.
1314   TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
1315   // Notify subclasses that we initiated the paint operation.
1316   DidInitiatePaint();
1317 }
1318
1319 void RenderWidget::didCompleteSwapBuffers() {
1320   TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1321
1322   // Notify subclasses threaded composited rendering was flushed to the screen.
1323   DidFlushPaint();
1324
1325   if (!next_paint_flags_ &&
1326       !need_update_rect_for_auto_resize_ &&
1327       !plugin_window_moves_.size()) {
1328     return;
1329   }
1330
1331   ViewHostMsg_UpdateRect_Params params;
1332   params.view_size = size_;
1333   params.plugin_window_moves.swap(plugin_window_moves_);
1334   params.flags = next_paint_flags_;
1335
1336   Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1337   next_paint_flags_ = 0;
1338   need_update_rect_for_auto_resize_ = false;
1339 }
1340
1341 void RenderWidget::scheduleComposite() {
1342   RenderThreadImpl* render_thread = RenderThreadImpl::current();
1343   // render_thread may be NULL in tests.
1344   if (render_thread && render_thread->compositor_message_loop_proxy().get() &&
1345       compositor_) {
1346     compositor_->setNeedsAnimate();
1347   }
1348 }
1349
1350 void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
1351   // TODO(darin): Eliminate this temporary.
1352   WebCursor cursor;
1353   InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
1354   // Only send a SetCursor message if we need to make a change.
1355   if (!current_cursor_.IsEqual(cursor)) {
1356     current_cursor_ = cursor;
1357     Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1358   }
1359 }
1360
1361 // We are supposed to get a single call to Show for a newly created RenderWidget
1362 // that was created via RenderWidget::CreateWebView.  So, we wait until this
1363 // point to dispatch the ShowWidget message.
1364 //
1365 // This method provides us with the information about how to display the newly
1366 // created RenderWidget (i.e., as a blocked popup or as a new tab).
1367 //
1368 void RenderWidget::show(WebNavigationPolicy) {
1369   DCHECK(!did_show_) << "received extraneous Show call";
1370   DCHECK(routing_id_ != MSG_ROUTING_NONE);
1371   DCHECK(opener_id_ != MSG_ROUTING_NONE);
1372
1373   if (did_show_)
1374     return;
1375
1376   did_show_ = true;
1377   // NOTE: initial_pos_ may still have its default values at this point, but
1378   // that's okay.  It'll be ignored if as_popup is false, or the browser
1379   // process will impose a default position otherwise.
1380   Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
1381   SetPendingWindowRect(initial_pos_);
1382 }
1383
1384 void RenderWidget::didFocus() {
1385 }
1386
1387 void RenderWidget::didBlur() {
1388 }
1389
1390 void RenderWidget::DoDeferredClose() {
1391   // No more compositing is possible.  This prevents shutdown races between
1392   // previously posted CreateOutputSurface tasks and the host being unable to
1393   // create them because the close message was handled.
1394   DestroyLayerTreeView();
1395   // Also prevent new compositors from being created.
1396   host_closing_ = true;
1397   Send(new ViewHostMsg_Close(routing_id_));
1398 }
1399
1400 void RenderWidget::closeWidgetSoon() {
1401   if (is_swapped_out_) {
1402     // This widget is currently swapped out, and the active widget is in a
1403     // different process.  Have the browser route the close request to the
1404     // active widget instead, so that the correct unload handlers are run.
1405     Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1406     return;
1407   }
1408
1409   // If a page calls window.close() twice, we'll end up here twice, but that's
1410   // OK.  It is safe to send multiple Close messages.
1411
1412   // Ask the RenderWidgetHost to initiate close.  We could be called from deep
1413   // in Javascript.  If we ask the RendwerWidgetHost to close now, the window
1414   // could be closed before the JS finishes executing.  So instead, post a
1415   // message back to the message loop, which won't run until the JS is
1416   // complete, and then the Close message can be sent.
1417   base::MessageLoop::current()->PostNonNestableTask(
1418       FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
1419 }
1420
1421 void RenderWidget::QueueSyntheticGesture(
1422     scoped_ptr<SyntheticGestureParams> gesture_params,
1423     const SyntheticGestureCompletionCallback& callback) {
1424   DCHECK(!callback.is_null());
1425
1426   pending_synthetic_gesture_callbacks_.push(callback);
1427
1428   SyntheticGesturePacket gesture_packet;
1429   gesture_packet.set_gesture_params(gesture_params.Pass());
1430
1431   Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
1432 }
1433
1434 void RenderWidget::Close() {
1435   screen_metrics_emulator_.reset();
1436   DestroyLayerTreeView();
1437   if (webwidget_) {
1438     webwidget_->close();
1439     webwidget_ = NULL;
1440   }
1441 }
1442
1443 WebRect RenderWidget::windowRect() {
1444   if (pending_window_rect_count_)
1445     return pending_window_rect_;
1446
1447   return view_screen_rect_;
1448 }
1449
1450 void RenderWidget::setToolTipText(const blink::WebString& text,
1451                                   WebTextDirection hint) {
1452   Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
1453 }
1454
1455 void RenderWidget::setWindowRect(const WebRect& rect) {
1456   WebRect pos = rect;
1457   if (popup_origin_scale_for_emulation_) {
1458     float scale = popup_origin_scale_for_emulation_;
1459     pos.x = popup_screen_origin_for_emulation_.x() +
1460         (pos.x - popup_view_origin_for_emulation_.x()) * scale;
1461     pos.y = popup_screen_origin_for_emulation_.y() +
1462         (pos.y - popup_view_origin_for_emulation_.y()) * scale;
1463   }
1464
1465   if (!resizing_mode_selector_->is_synchronous_mode()) {
1466     if (did_show_) {
1467       Send(new ViewHostMsg_RequestMove(routing_id_, pos));
1468       SetPendingWindowRect(pos);
1469     } else {
1470       initial_pos_ = pos;
1471     }
1472   } else {
1473     ResizeSynchronously(pos);
1474   }
1475 }
1476
1477 void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1478   pending_window_rect_ = rect;
1479   pending_window_rect_count_++;
1480 }
1481
1482 WebRect RenderWidget::rootWindowRect() {
1483   if (pending_window_rect_count_) {
1484     // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1485     // the RootWindowRect is probably going to return wrong results since the
1486     // browser may not have processed the Move yet.  There isn't really anything
1487     // good to do in this case, and it shouldn't happen - since this size is
1488     // only really needed for windowToScreen, which is only used for Popups.
1489     return pending_window_rect_;
1490   }
1491
1492   return window_screen_rect_;
1493 }
1494
1495 WebRect RenderWidget::windowResizerRect() {
1496   return resizer_rect_;
1497 }
1498
1499 void RenderWidget::OnSetInputMethodActive(bool is_active) {
1500   // To prevent this renderer process from sending unnecessary IPC messages to
1501   // a browser process, we permit the renderer process to send IPC messages
1502   // only during the input method attached to the browser process is active.
1503   input_method_is_active_ = is_active;
1504 }
1505
1506 void RenderWidget::OnCandidateWindowShown() {
1507   webwidget_->didShowCandidateWindow();
1508 }
1509
1510 void RenderWidget::OnCandidateWindowUpdated() {
1511   webwidget_->didUpdateCandidateWindow();
1512 }
1513
1514 void RenderWidget::OnCandidateWindowHidden() {
1515   webwidget_->didHideCandidateWindow();
1516 }
1517
1518 void RenderWidget::OnImeSetComposition(
1519     const base::string16& text,
1520     const std::vector<WebCompositionUnderline>& underlines,
1521     int selection_start, int selection_end) {
1522   if (!ShouldHandleImeEvent())
1523     return;
1524   ImeEventGuard guard(this);
1525   if (!webwidget_->setComposition(
1526       text, WebVector<WebCompositionUnderline>(underlines),
1527       selection_start, selection_end)) {
1528     // If we failed to set the composition text, then we need to let the browser
1529     // process to cancel the input method's ongoing composition session, to make
1530     // sure we are in a consistent state.
1531     Send(new InputHostMsg_ImeCancelComposition(routing_id()));
1532   }
1533 #if defined(OS_MACOSX) || defined(USE_AURA)
1534   UpdateCompositionInfo(true);
1535 #endif
1536 }
1537
1538 void RenderWidget::OnImeConfirmComposition(const base::string16& text,
1539                                            const gfx::Range& replacement_range,
1540                                            bool keep_selection) {
1541   if (!ShouldHandleImeEvent())
1542     return;
1543   ImeEventGuard guard(this);
1544   handling_input_event_ = true;
1545   if (text.length())
1546     webwidget_->confirmComposition(text);
1547   else if (keep_selection)
1548     webwidget_->confirmComposition(WebWidget::KeepSelection);
1549   else
1550     webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
1551   handling_input_event_ = false;
1552 #if defined(OS_MACOSX) || defined(USE_AURA)
1553   UpdateCompositionInfo(true);
1554 #endif
1555 }
1556
1557 void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
1558   // During shutdown we can just ignore this message.
1559   if (!webwidget_)
1560     return;
1561
1562   // Even if the browser provides an empty damage rect, it's still expecting to
1563   // receive a repaint ack so just damage the entire widget bounds.
1564   if (size_to_paint.IsEmpty()) {
1565     size_to_paint = size_;
1566   }
1567
1568   set_next_paint_is_repaint_ack();
1569   if (compositor_)
1570     compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
1571 }
1572
1573 void RenderWidget::OnSyntheticGestureCompleted() {
1574   DCHECK(!pending_synthetic_gesture_callbacks_.empty());
1575
1576   pending_synthetic_gesture_callbacks_.front().Run();
1577   pending_synthetic_gesture_callbacks_.pop();
1578 }
1579
1580 void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
1581   if (!webwidget_)
1582     return;
1583   webwidget_->setTextDirection(direction);
1584 }
1585
1586 void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1587                                        const gfx::Rect& window_screen_rect) {
1588   if (screen_metrics_emulator_) {
1589     screen_metrics_emulator_->OnUpdateScreenRectsMessage(
1590         view_screen_rect, window_screen_rect);
1591   } else {
1592     view_screen_rect_ = view_screen_rect;
1593     window_screen_rect_ = window_screen_rect;
1594   }
1595   Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1596 }
1597
1598 void RenderWidget::showImeIfNeeded() {
1599   OnShowImeIfNeeded();
1600 }
1601
1602 void RenderWidget::OnShowImeIfNeeded() {
1603 #if defined(OS_ANDROID) || defined(USE_AURA)
1604   UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
1605 #endif
1606 }
1607
1608 #if defined(OS_ANDROID)
1609 void RenderWidget::IncrementOutstandingImeEventAcks() {
1610   ++outstanding_ime_acks_;
1611 }
1612
1613 void RenderWidget::OnImeEventAck() {
1614   --outstanding_ime_acks_;
1615   DCHECK(outstanding_ime_acks_ >= 0);
1616 }
1617 #endif
1618
1619 bool RenderWidget::ShouldHandleImeEvent() {
1620 #if defined(OS_ANDROID)
1621   return !!webwidget_ && outstanding_ime_acks_ == 0;
1622 #else
1623   return !!webwidget_;
1624 #endif
1625 }
1626
1627 bool RenderWidget::SendAckForMouseMoveFromDebugger() {
1628   if (handling_event_type_ == WebInputEvent::MouseMove) {
1629     // If we pause multiple times during a single mouse move event, we should
1630     // only send ACK once.
1631     if (!ignore_ack_for_mouse_move_from_debugger_) {
1632       InputHostMsg_HandleInputEvent_ACK_Params ack;
1633       ack.type = handling_event_type_;
1634       ack.state = INPUT_EVENT_ACK_STATE_CONSUMED;
1635       Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
1636     }
1637     return true;
1638   }
1639   return false;
1640 }
1641
1642 void RenderWidget::IgnoreAckForMouseMoveFromDebugger() {
1643   ignore_ack_for_mouse_move_from_debugger_ = true;
1644 }
1645
1646 void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
1647   if (device_scale_factor_ == device_scale_factor)
1648     return;
1649
1650   device_scale_factor_ = device_scale_factor;
1651   scheduleComposite();
1652 }
1653
1654 bool RenderWidget::SetDeviceColorProfile(
1655     const std::vector<char>& color_profile) {
1656   if (device_color_profile_ == color_profile)
1657     return false;
1658
1659   device_color_profile_ = color_profile;
1660   return true;
1661 }
1662
1663 void RenderWidget::ResetDeviceColorProfileForTesting() {
1664   if (!device_color_profile_.empty())
1665     device_color_profile_.clear();
1666   device_color_profile_.push_back('0');
1667 }
1668
1669 void RenderWidget::OnOrientationChange() {
1670 }
1671
1672 gfx::Vector2d RenderWidget::GetScrollOffset() {
1673   // Bare RenderWidgets don't support scroll offset.
1674   return gfx::Vector2d();
1675 }
1676
1677 void RenderWidget::SetHidden(bool hidden) {
1678   if (is_hidden_ == hidden)
1679     return;
1680
1681   // The status has changed.  Tell the RenderThread about it.
1682   is_hidden_ = hidden;
1683   if (is_hidden_)
1684     RenderThreadImpl::current()->WidgetHidden();
1685   else
1686     RenderThreadImpl::current()->WidgetRestored();
1687 }
1688
1689 void RenderWidget::WillToggleFullscreen() {
1690   if (!webwidget_)
1691     return;
1692
1693   if (is_fullscreen_) {
1694     webwidget_->willExitFullScreen();
1695   } else {
1696     webwidget_->willEnterFullScreen();
1697   }
1698 }
1699
1700 void RenderWidget::DidToggleFullscreen() {
1701   if (!webwidget_)
1702     return;
1703
1704   if (is_fullscreen_) {
1705     webwidget_->didEnterFullScreen();
1706   } else {
1707     webwidget_->didExitFullScreen();
1708   }
1709 }
1710
1711 bool RenderWidget::next_paint_is_resize_ack() const {
1712   return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
1713 }
1714
1715 void RenderWidget::set_next_paint_is_resize_ack() {
1716   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
1717 }
1718
1719 void RenderWidget::set_next_paint_is_repaint_ack() {
1720   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
1721 }
1722
1723 static bool IsDateTimeInput(ui::TextInputType type) {
1724   return type == ui::TEXT_INPUT_TYPE_DATE ||
1725       type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
1726       type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
1727       type == ui::TEXT_INPUT_TYPE_MONTH ||
1728       type == ui::TEXT_INPUT_TYPE_TIME ||
1729       type == ui::TEXT_INPUT_TYPE_WEEK;
1730 }
1731
1732
1733 void RenderWidget::StartHandlingImeEvent() {
1734   DCHECK(!handling_ime_event_);
1735   handling_ime_event_ = true;
1736 }
1737
1738 void RenderWidget::FinishHandlingImeEvent() {
1739   DCHECK(handling_ime_event_);
1740   handling_ime_event_ = false;
1741   // While handling an ime event, text input state and selection bounds updates
1742   // are ignored. These must explicitly be updated once finished handling the
1743   // ime event.
1744   UpdateSelectionBounds();
1745 #if defined(OS_ANDROID)
1746   UpdateTextInputState(NO_SHOW_IME, FROM_IME);
1747 #endif
1748 }
1749
1750 void RenderWidget::UpdateTextInputState(ShowIme show_ime,
1751                                         ChangeSource change_source) {
1752   if (handling_ime_event_)
1753     return;
1754   if (show_ime == NO_SHOW_IME && !input_method_is_active_)
1755     return;
1756   ui::TextInputType new_type = GetTextInputType();
1757   if (IsDateTimeInput(new_type))
1758     return;  // Not considered as a text input field in WebKit/Chromium.
1759
1760   blink::WebTextInputInfo new_info;
1761   if (webwidget_)
1762     new_info = webwidget_->textInputInfo();
1763   const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
1764
1765   bool new_can_compose_inline = CanComposeInline();
1766
1767   // Only sends text input params if they are changed or if the ime should be
1768   // shown.
1769   if (show_ime == SHOW_IME_IF_NEEDED ||
1770       (text_input_type_ != new_type ||
1771        text_input_mode_ != new_mode ||
1772        text_input_info_ != new_info ||
1773        can_compose_inline_ != new_can_compose_inline)
1774 #if defined(OS_ANDROID)
1775       || text_field_is_dirty_
1776 #endif
1777       ) {
1778     ViewHostMsg_TextInputState_Params p;
1779     p.type = new_type;
1780     p.flags = new_info.flags;
1781     p.mode = new_mode;
1782     p.value = new_info.value.utf8();
1783     p.selection_start = new_info.selectionStart;
1784     p.selection_end = new_info.selectionEnd;
1785     p.composition_start = new_info.compositionStart;
1786     p.composition_end = new_info.compositionEnd;
1787     p.can_compose_inline = new_can_compose_inline;
1788     p.show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
1789 #if defined(USE_AURA)
1790     p.is_non_ime_change = true;
1791 #endif
1792 #if defined(OS_ANDROID)
1793     p.is_non_ime_change = (change_source == FROM_NON_IME) ||
1794                          text_field_is_dirty_;
1795     if (p.is_non_ime_change)
1796       IncrementOutstandingImeEventAcks();
1797     text_field_is_dirty_ = false;
1798 #endif
1799     Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
1800
1801     text_input_info_ = new_info;
1802     text_input_type_ = new_type;
1803     text_input_mode_ = new_mode;
1804     can_compose_inline_ = new_can_compose_inline;
1805   }
1806 }
1807
1808 void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
1809   WebRect focus_webrect;
1810   WebRect anchor_webrect;
1811   webwidget_->selectionBounds(focus_webrect, anchor_webrect);
1812   *focus = focus_webrect;
1813   *anchor = anchor_webrect;
1814 }
1815
1816 void RenderWidget::UpdateSelectionBounds() {
1817   if (!webwidget_)
1818     return;
1819   if (handling_ime_event_)
1820     return;
1821
1822   // With composited selection updates, the selection bounds will be reported
1823   // directly by the compositor, in which case explicit IPC selection
1824   // notifications should be suppressed.
1825   if (!blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled()) {
1826     ViewHostMsg_SelectionBounds_Params params;
1827     GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
1828     if (selection_anchor_rect_ != params.anchor_rect ||
1829         selection_focus_rect_ != params.focus_rect) {
1830       selection_anchor_rect_ = params.anchor_rect;
1831       selection_focus_rect_ = params.focus_rect;
1832       webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
1833       params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
1834       Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
1835     }
1836   }
1837
1838 #if defined(OS_MACOSX) || defined(USE_AURA)
1839   UpdateCompositionInfo(false);
1840 #endif
1841 }
1842
1843 // Check blink::WebTextInputType and ui::TextInputType is kept in sync.
1844 COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
1845                int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
1846 COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
1847                int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
1848 COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
1849                int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
1850 COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
1851                int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
1852 COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
1853                int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
1854 COMPILE_ASSERT(int(blink::WebTextInputTypeNumber) == \
1855                int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
1856 COMPILE_ASSERT(int(blink::WebTextInputTypeTelephone) == \
1857                int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
1858 COMPILE_ASSERT(int(blink::WebTextInputTypeURL) == \
1859                int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
1860 COMPILE_ASSERT(int(blink::WebTextInputTypeDate) == \
1861                int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
1862 COMPILE_ASSERT(int(blink::WebTextInputTypeDateTime) == \
1863                int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
1864 COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeLocal) == \
1865                int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
1866 COMPILE_ASSERT(int(blink::WebTextInputTypeMonth) == \
1867                int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
1868 COMPILE_ASSERT(int(blink::WebTextInputTypeTime) == \
1869                int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
1870 COMPILE_ASSERT(int(blink::WebTextInputTypeWeek) == \
1871                int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
1872 COMPILE_ASSERT(int(blink::WebTextInputTypeTextArea) == \
1873                int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
1874 COMPILE_ASSERT(int(blink::WebTextInputTypeContentEditable) == \
1875                int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
1876 COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeField) == \
1877                int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
1878
1879 ui::TextInputType RenderWidget::WebKitToUiTextInputType(
1880     blink::WebTextInputType type) {
1881   // Check the type is in the range representable by ui::TextInputType.
1882   DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
1883     "blink::WebTextInputType and ui::TextInputType not synchronized";
1884   return static_cast<ui::TextInputType>(type);
1885 }
1886
1887 ui::TextInputType RenderWidget::GetTextInputType() {
1888   if (webwidget_)
1889     return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
1890   return ui::TEXT_INPUT_TYPE_NONE;
1891 }
1892
1893 #if defined(OS_MACOSX) || defined(USE_AURA)
1894 void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
1895   gfx::Range range = gfx::Range();
1896   if (should_update_range) {
1897     GetCompositionRange(&range);
1898   } else {
1899     range = composition_range_;
1900   }
1901   std::vector<gfx::Rect> character_bounds;
1902   GetCompositionCharacterBounds(&character_bounds);
1903
1904   if (!ShouldUpdateCompositionInfo(range, character_bounds))
1905     return;
1906   composition_character_bounds_ = character_bounds;
1907   composition_range_ = range;
1908   Send(new InputHostMsg_ImeCompositionRangeChanged(
1909       routing_id(), composition_range_, composition_character_bounds_));
1910 }
1911
1912 void RenderWidget::GetCompositionCharacterBounds(
1913     std::vector<gfx::Rect>* bounds) {
1914   DCHECK(bounds);
1915   bounds->clear();
1916 }
1917
1918 void RenderWidget::GetCompositionRange(gfx::Range* range) {
1919   size_t location, length;
1920   if (webwidget_->compositionRange(&location, &length)) {
1921     range->set_start(location);
1922     range->set_end(location + length);
1923   } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
1924     range->set_start(location);
1925     range->set_end(location + length);
1926   } else {
1927     *range = gfx::Range::InvalidRange();
1928   }
1929 }
1930
1931 bool RenderWidget::ShouldUpdateCompositionInfo(
1932     const gfx::Range& range,
1933     const std::vector<gfx::Rect>& bounds) {
1934   if (composition_range_ != range)
1935     return true;
1936   if (bounds.size() != composition_character_bounds_.size())
1937     return true;
1938   for (size_t i = 0; i < bounds.size(); ++i) {
1939     if (bounds[i] != composition_character_bounds_[i])
1940       return true;
1941   }
1942   return false;
1943 }
1944 #endif
1945
1946 #if defined(OS_ANDROID)
1947 void RenderWidget::DidChangeBodyBackgroundColor(SkColor bg_color) {
1948   // If not initialized, default to white. Note that 0 is different from black
1949   // as black still has alpha 0xFF.
1950   if (!bg_color)
1951     bg_color = SK_ColorWHITE;
1952
1953   if (bg_color != body_background_color_) {
1954     body_background_color_ = bg_color;
1955     Send(new ViewHostMsg_DidChangeBodyBackgroundColor(routing_id(), bg_color));
1956   }
1957 }
1958 #endif
1959
1960 bool RenderWidget::CanComposeInline() {
1961   return true;
1962 }
1963
1964 WebScreenInfo RenderWidget::screenInfo() {
1965   return screen_info_;
1966 }
1967
1968 float RenderWidget::deviceScaleFactor() {
1969   return device_scale_factor_;
1970 }
1971
1972 void RenderWidget::resetInputMethod() {
1973   if (!input_method_is_active_)
1974     return;
1975
1976   ImeEventGuard guard(this);
1977   // If the last text input type is not None, then we should finish any
1978   // ongoing composition regardless of the new text input type.
1979   if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
1980     // If a composition text exists, then we need to let the browser process
1981     // to cancel the input method's ongoing composition session.
1982     if (webwidget_->confirmComposition())
1983       Send(new InputHostMsg_ImeCancelComposition(routing_id()));
1984   }
1985
1986 #if defined(OS_MACOSX) || defined(USE_AURA)
1987   UpdateCompositionInfo(true);
1988 #endif
1989 }
1990
1991 void RenderWidget::didHandleGestureEvent(
1992     const WebGestureEvent& event,
1993     bool event_cancelled) {
1994 #if defined(OS_ANDROID) || defined(USE_AURA)
1995   if (event_cancelled)
1996     return;
1997   if (event.type == WebInputEvent::GestureTap) {
1998     UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
1999   } else if (event.type == WebInputEvent::GestureLongPress) {
2000     DCHECK(webwidget_);
2001     if (webwidget_->textInputInfo().value.isEmpty())
2002       UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
2003     else
2004       UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
2005   }
2006 #endif
2007 }
2008
2009 void RenderWidget::StartCompositor() {
2010   // For widgets that are never visible, we don't need the compositor to run
2011   // at all.
2012   if (never_visible_)
2013     return;
2014   compositor_->setSurfaceReady();
2015 }
2016
2017 void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
2018   size_t i = 0;
2019   for (; i < plugin_window_moves_.size(); ++i) {
2020     if (plugin_window_moves_[i].window == move.window) {
2021       if (move.rects_valid) {
2022         plugin_window_moves_[i] = move;
2023       } else {
2024         plugin_window_moves_[i].visible = move.visible;
2025       }
2026       break;
2027     }
2028   }
2029
2030   if (i == plugin_window_moves_.size())
2031     plugin_window_moves_.push_back(move);
2032 }
2033
2034 void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2035   for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2036        i != plugin_window_moves_.end(); ++i) {
2037     if (i->window == window) {
2038       plugin_window_moves_.erase(i);
2039       break;
2040     }
2041   }
2042 }
2043
2044
2045 RenderWidgetCompositor* RenderWidget::compositor() const {
2046   return compositor_.get();
2047 }
2048
2049 bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
2050   return false;
2051 }
2052
2053 bool RenderWidget::WillHandleGestureEvent(
2054     const blink::WebGestureEvent& event) {
2055   return false;
2056 }
2057
2058 void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2059   Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2060 }
2061
2062 void RenderWidget::setTouchAction(
2063     blink::WebTouchAction web_touch_action) {
2064
2065   // Ignore setTouchAction calls that result from synthetic touch events (eg.
2066   // when blink is emulating touch with mouse).
2067   if (handling_event_type_ != WebInputEvent::TouchStart)
2068     return;
2069
2070    // Verify the same values are used by the types so we can cast between them.
2071    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_AUTO) ==
2072                       blink::WebTouchActionAuto,
2073                   enum_values_must_match_for_touch_action);
2074    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_NONE) ==
2075                       blink::WebTouchActionNone,
2076                   enum_values_must_match_for_touch_action);
2077    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_X) ==
2078                       blink::WebTouchActionPanX,
2079                   enum_values_must_match_for_touch_action);
2080    COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_Y) ==
2081                       blink::WebTouchActionPanY,
2082                   enum_values_must_match_for_touch_action);
2083    COMPILE_ASSERT(
2084        static_cast<blink::WebTouchAction>(TOUCH_ACTION_PINCH_ZOOM) ==
2085            blink::WebTouchActionPinchZoom,
2086        enum_values_must_match_for_touch_action);
2087
2088    content::TouchAction content_touch_action =
2089        static_cast<content::TouchAction>(web_touch_action);
2090   Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2091 }
2092
2093 void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
2094 #if defined(OS_ANDROID)
2095   text_field_is_dirty_ = true;
2096 #endif
2097 }
2098
2099 bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2100   return true;
2101 }
2102
2103 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
2104 RenderWidget::CreateGraphicsContext3D() {
2105   if (!webwidget_)
2106     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2107   if (CommandLine::ForCurrentProcess()->HasSwitch(
2108           switches::kDisableGpuCompositing))
2109     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2110   if (!RenderThreadImpl::current())
2111     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2112   CauseForGpuLaunch cause =
2113       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
2114   scoped_refptr<GpuChannelHost> gpu_channel_host(
2115       RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
2116   if (!gpu_channel_host.get())
2117     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2118
2119   // Explicitly disable antialiasing for the compositor. As of the time of
2120   // this writing, the only platform that supported antialiasing for the
2121   // compositor was Mac OS X, because the on-screen OpenGL context creation
2122   // code paths on Windows and Linux didn't yet have multisampling support.
2123   // Mac OS X essentially always behaves as though it's rendering offscreen.
2124   // Multisampling has a heavy cost especially on devices with relatively low
2125   // fill rate like most notebooks, and the Mac implementation would need to
2126   // be optimized to resolve directly into the IOSurface shared between the
2127   // GPU and browser processes. For these reasons and to avoid platform
2128   // disparities we explicitly disable antialiasing.
2129   blink::WebGraphicsContext3D::Attributes attributes;
2130   attributes.antialias = false;
2131   attributes.shareResources = true;
2132   attributes.noAutomaticFlushes = true;
2133   attributes.depth = false;
2134   attributes.stencil = false;
2135   bool lose_context_when_out_of_memory = true;
2136   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
2137 #if defined(OS_ANDROID)
2138   // If we raster too fast we become upload bound, and pending
2139   // uploads consume memory. For maximum upload throughput, we would
2140   // want to allow for upload_throughput * pipeline_time of pending
2141   // uploads, after which we are just wasting memory. Since we don't
2142   // know our upload throughput yet, this just caps our memory usage.
2143   size_t divider = 1;
2144   if (base::SysInfo::IsLowEndDevice())
2145     divider = 6;
2146   // For reference Nexus10 can upload 1MB in about 2.5ms.
2147   const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
2148   // Deadline to draw a frame to achieve 60 frames per second.
2149   const size_t kMillisecondsPerFrame = 16;
2150   // Assuming a two frame deep pipeline between the CPU and the GPU.
2151   size_t max_transfer_buffer_usage_mb =
2152       static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2153   static const size_t kBytesPerMegabyte = 1024 * 1024;
2154   // We keep the MappedMemoryReclaimLimit the same as the upload limit
2155   // to avoid unnecessarily stalling the compositor thread.
2156   limits.mapped_memory_reclaim_limit =
2157       max_transfer_buffer_usage_mb * kBytesPerMegabyte;
2158 #endif
2159
2160   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
2161       new WebGraphicsContext3DCommandBufferImpl(surface_id(),
2162                                                 GetURLForGraphicsContext3D(),
2163                                                 gpu_channel_host.get(),
2164                                                 attributes,
2165                                                 lose_context_when_out_of_memory,
2166                                                 limits,
2167                                                 NULL));
2168   return context.Pass();
2169 }
2170
2171 void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2172   render_frame_proxies_.AddObserver(proxy);
2173 }
2174
2175 void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2176   render_frame_proxies_.RemoveObserver(proxy);
2177 }
2178
2179 void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2180   render_frames_.AddObserver(frame);
2181 }
2182
2183 void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2184   render_frames_.RemoveObserver(frame);
2185 }
2186
2187 #if defined(VIDEO_HOLE)
2188 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
2189   video_hole_frames_.AddObserver(frame);
2190 }
2191
2192 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
2193   video_hole_frames_.RemoveObserver(frame);
2194 }
2195 #endif  // defined(VIDEO_HOLE)
2196
2197 }  // namespace content