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 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_ 6 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_ 7 8 #include <deque> 9 #include <list> 10 #include <map> 11 #include <queue> 12 #include <string> 13 #include <utility> 14 #include <vector> 15 16 #include "base/callback.h" 17 #include "base/gtest_prod_util.h" 18 #include "base/memory/scoped_ptr.h" 19 #include "base/memory/weak_ptr.h" 20 #include "base/observer_list.h" 21 #include "base/process/kill.h" 22 #include "base/strings/string16.h" 23 #include "base/time/time.h" 24 #include "base/timer/timer.h" 25 #include "build/build_config.h" 26 #include "content/browser/renderer_host/input/input_ack_handler.h" 27 #include "content/browser/renderer_host/input/input_router_client.h" 28 #include "content/common/browser_rendering_stats.h" 29 #include "content/common/input/synthetic_gesture_packet.h" 30 #include "content/common/view_message_enums.h" 31 #include "content/port/browser/event_with_latency_info.h" 32 #include "content/port/common/input_event_ack_state.h" 33 #include "content/public/browser/render_widget_host.h" 34 #include "content/public/common/page_zoom.h" 35 #include "ipc/ipc_listener.h" 36 #include "ui/base/ime/text_input_mode.h" 37 #include "ui/base/ime/text_input_type.h" 38 #include "ui/events/latency_info.h" 39 #include "ui/gfx/native_widget_types.h" 40 41 class WebCursor; 42 struct AcceleratedSurfaceMsg_BufferPresented_Params; 43 struct ViewHostMsg_CompositorSurfaceBuffersSwapped_Params; 44 struct ViewHostMsg_UpdateRect_Params; 45 struct ViewHostMsg_TextInputState_Params; 46 struct ViewHostMsg_BeginSmoothScroll_Params; 47 48 namespace base { 49 class TimeTicks; 50 } 51 52 namespace cc { 53 class CompositorFrame; 54 class CompositorFrameAck; 55 } 56 57 namespace gfx { 58 class Range; 59 } 60 61 namespace ui { 62 class KeyEvent; 63 } 64 65 namespace blink { 66 class WebInputEvent; 67 class WebMouseEvent; 68 struct WebCompositionUnderline; 69 struct WebScreenInfo; 70 } 71 72 #if defined(OS_ANDROID) 73 namespace blink { 74 class WebLayer; 75 } 76 #endif 77 78 namespace content { 79 class BackingStore; 80 class InputRouter; 81 class MockRenderWidgetHost; 82 class OverscrollController; 83 class RenderWidgetHostDelegate; 84 class RenderWidgetHostViewPort; 85 class SyntheticGestureController; 86 class TimeoutMonitor; 87 struct EditCommand; 88 89 // This implements the RenderWidgetHost interface that is exposed to 90 // embedders of content, and adds things only visible to content. 91 class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, 92 public InputRouterClient, 93 public InputAckHandler, 94 public IPC::Listener { 95 public: 96 // routing_id can be MSG_ROUTING_NONE, in which case the next available 97 // routing id is taken from the RenderProcessHost. 98 // If this object outlives |delegate|, DetachDelegate() must be called when 99 // |delegate| goes away. 100 RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate, 101 RenderProcessHost* process, 102 int routing_id, 103 bool hidden); 104 virtual ~RenderWidgetHostImpl(); 105 106 // Similar to RenderWidgetHost::FromID, but returning the Impl object. 107 static RenderWidgetHostImpl* FromID(int32 process_id, int32 routing_id); 108 109 // Returns all RenderWidgetHosts including swapped out ones for 110 // internal use. The public interface 111 // RendgerWidgetHost::GetRenderWidgetHosts only returns active ones. 112 static scoped_ptr<RenderWidgetHostIterator> GetAllRenderWidgetHosts(); 113 114 // Use RenderWidgetHostImpl::From(rwh) to downcast a 115 // RenderWidgetHost to a RenderWidgetHostImpl. Internally, this 116 // uses RenderWidgetHost::AsRenderWidgetHostImpl(). 117 static RenderWidgetHostImpl* From(RenderWidgetHost* rwh); 118 119 void set_hung_renderer_delay_ms(const base::TimeDelta& timeout) { 120 hung_renderer_delay_ms_ = timeout.InMilliseconds(); 121 } 122 123 // RenderWidgetHost implementation. 124 virtual void Undo() OVERRIDE; 125 virtual void Redo() OVERRIDE; 126 virtual void Cut() OVERRIDE; 127 virtual void Copy() OVERRIDE; 128 virtual void CopyToFindPboard() OVERRIDE; 129 virtual void Paste() OVERRIDE; 130 virtual void PasteAndMatchStyle() OVERRIDE; 131 virtual void Delete() OVERRIDE; 132 virtual void SelectAll() OVERRIDE; 133 virtual void Unselect() OVERRIDE; 134 virtual void UpdateTextDirection(blink::WebTextDirection direction) OVERRIDE; 135 virtual void NotifyTextDirection() OVERRIDE; 136 virtual void Focus() OVERRIDE; 137 virtual void Blur() OVERRIDE; 138 virtual void SetActive(bool active) OVERRIDE; 139 virtual void CopyFromBackingStore( 140 const gfx::Rect& src_rect, 141 const gfx::Size& accelerated_dst_size, 142 const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE; 143 #if defined(TOOLKIT_GTK) 144 virtual bool CopyFromBackingStoreToGtkWindow(const gfx::Rect& dest_rect, 145 GdkWindow* target) OVERRIDE; 146 #elif defined(OS_MACOSX) 147 virtual gfx::Size GetBackingStoreSize() OVERRIDE; 148 virtual bool CopyFromBackingStoreToCGContext(const CGRect& dest_rect, 149 CGContextRef target) OVERRIDE; 150 #endif 151 virtual void EnableFullAccessibilityMode() OVERRIDE; 152 virtual void ForwardMouseEvent( 153 const blink::WebMouseEvent& mouse_event) OVERRIDE; 154 virtual void ForwardWheelEvent( 155 const blink::WebMouseWheelEvent& wheel_event) OVERRIDE; 156 virtual void ForwardKeyboardEvent( 157 const NativeWebKeyboardEvent& key_event) OVERRIDE; 158 virtual const gfx::Vector2d& GetLastScrollOffset() const OVERRIDE; 159 virtual RenderProcessHost* GetProcess() const OVERRIDE; 160 virtual int GetRoutingID() const OVERRIDE; 161 virtual RenderWidgetHostView* GetView() const OVERRIDE; 162 virtual bool IsLoading() const OVERRIDE; 163 virtual bool IsRenderView() const OVERRIDE; 164 virtual void PaintAtSize(TransportDIB::Handle dib_handle, 165 int tag, 166 const gfx::Size& page_size, 167 const gfx::Size& desired_size) OVERRIDE; 168 virtual void Replace(const base::string16& word) OVERRIDE; 169 virtual void ReplaceMisspelling(const base::string16& word) OVERRIDE; 170 virtual void ResizeRectChanged(const gfx::Rect& new_rect) OVERRIDE; 171 virtual void RestartHangMonitorTimeout() OVERRIDE; 172 virtual void SetIgnoreInputEvents(bool ignore_input_events) OVERRIDE; 173 virtual void Stop() OVERRIDE; 174 virtual void WasResized() OVERRIDE; 175 virtual void AddKeyPressEventCallback( 176 const KeyPressEventCallback& callback) OVERRIDE; 177 virtual void RemoveKeyPressEventCallback( 178 const KeyPressEventCallback& callback) OVERRIDE; 179 virtual void AddMouseEventCallback( 180 const MouseEventCallback& callback) OVERRIDE; 181 virtual void RemoveMouseEventCallback( 182 const MouseEventCallback& callback) OVERRIDE; 183 virtual void GetWebScreenInfo(blink::WebScreenInfo* result) OVERRIDE; 184 virtual void GetSnapshotFromRenderer( 185 const gfx::Rect& src_subrect, 186 const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE; 187 188 const NativeWebKeyboardEvent* GetLastKeyboardEvent() const; 189 190 // Notification that the screen info has changed. 191 void NotifyScreenInfoChanged(); 192 193 // Invalidates the cached screen info so that next resize request 194 // will carry the up to date screen info. Unlike 195 // |NotifyScreenInfoChanged|, this doesn't send a message to the renderer. 196 void InvalidateScreenInfo(); 197 198 // Sets the View of this RenderWidgetHost. 199 void SetView(RenderWidgetHostView* view); 200 201 int surface_id() const { return surface_id_; } 202 203 bool empty() const { return current_size_.IsEmpty(); } 204 205 // Called when a renderer object already been created for this host, and we 206 // just need to be attached to it. Used for window.open, <select> dropdown 207 // menus, and other times when the renderer initiates creating an object. 208 virtual void Init(); 209 210 // Tells the renderer to die and then calls Destroy(). 211 virtual void Shutdown(); 212 213 // IPC::Listener 214 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE; 215 216 // Sends a message to the corresponding object in the renderer. 217 virtual bool Send(IPC::Message* msg) OVERRIDE; 218 219 // Called to notify the RenderWidget that it has been hidden or restored from 220 // having been hidden. 221 void WasHidden(); 222 void WasShown(); 223 224 // Returns true if the RenderWidget is hidden. 225 bool is_hidden() const { return is_hidden_; } 226 227 // Called to notify the RenderWidget that its associated native window 228 // got/lost focused. 229 virtual void GotFocus(); 230 virtual void LostCapture(); 231 232 // Called to notify the RenderWidget that it has lost the mouse lock. 233 virtual void LostMouseLock(); 234 235 // Noifies the RenderWidget of the current mouse cursor visibility state. 236 void SendCursorVisibilityState(bool is_visible); 237 238 // Tells us whether the page is rendered directly via the GPU process. 239 bool is_accelerated_compositing_active() { 240 return is_accelerated_compositing_active_; 241 } 242 243 // Notifies the RenderWidgetHost that the View was destroyed. 244 void ViewDestroyed(); 245 246 // Indicates if the page has finished loading. 247 void SetIsLoading(bool is_loading); 248 249 // Check for the existance of a BackingStore of the given |desired_size| and 250 // return it if it exists. If the BackingStore is GPU, true is returned and 251 // |*backing_store| is set to NULL. 252 bool TryGetBackingStore(const gfx::Size& desired_size, 253 BackingStore** backing_store); 254 255 // Get access to the widget's backing store matching the size of the widget's 256 // view. If you pass |force_create| as true, then GetBackingStore may block 257 // for the renderer to send a new frame. Otherwise, NULL will be returned if 258 // the backing store doesn't already exist. It will also return NULL if the 259 // backing store could not be created. 260 // 261 // Mac only: NULL may also be returned if the last frame was GPU accelerated. 262 // Call GetView()->HasAcceleratedSurface to determine if the last frame was 263 // accelerated. 264 BackingStore* GetBackingStore(bool force_create); 265 266 // Allocate a new backing store of the given size. Returns NULL on failure 267 // (for example, if we don't currently have a RenderWidgetHostView.) 268 BackingStore* AllocBackingStore(const gfx::Size& size); 269 270 // When a backing store does asynchronous painting, it will call this function 271 // when it is done with the DIB. We will then forward a message to the 272 // renderer to send another paint. 273 void DonePaintingToBackingStore(); 274 275 // GPU accelerated version of GetBackingStore function. This will 276 // trigger a re-composite to the view. It may fail if a resize is pending, or 277 // if a composite has already been requested and not acked yet. 278 bool ScheduleComposite(); 279 280 // Starts a hang monitor timeout. If there's already a hang monitor timeout 281 // the new one will only fire if it has a shorter delay than the time 282 // left on the existing timeouts. 283 void StartHangMonitorTimeout(base::TimeDelta delay); 284 285 // Stops all existing hang monitor timeouts and assumes the renderer is 286 // responsive. 287 void StopHangMonitorTimeout(); 288 289 // Forwards the given message to the renderer. These are called by the view 290 // when it has received a message. 291 void ForwardGestureEvent(const blink::WebGestureEvent& gesture_event); 292 void ForwardGestureEventWithLatencyInfo( 293 const blink::WebGestureEvent& gesture_event, 294 const ui::LatencyInfo& ui_latency); 295 void ForwardTouchEventWithLatencyInfo( 296 const blink::WebTouchEvent& touch_event, 297 const ui::LatencyInfo& ui_latency); 298 void ForwardMouseEventWithLatencyInfo( 299 const MouseEventWithLatencyInfo& mouse_event); 300 void ForwardWheelEventWithLatencyInfo( 301 const MouseWheelEventWithLatencyInfo& wheel_event); 302 303 void CancelUpdateTextDirection(); 304 305 // Called when a mouse click/gesture tap activates the renderer. 306 virtual void OnPointerEventActivate(); 307 308 // Notifies the renderer whether or not the input method attached to this 309 // process is activated. 310 // When the input method is activated, a renderer process sends IPC messages 311 // to notify the status of its composition node. (This message is mainly used 312 // for notifying the position of the input cursor so that the browser can 313 // display input method windows under the cursor.) 314 void SetInputMethodActive(bool activate); 315 316 // Notifies the renderer changes of IME candidate window state. 317 void CandidateWindowShown(); 318 void CandidateWindowUpdated(); 319 void CandidateWindowHidden(); 320 321 // Update the composition node of the renderer (or WebKit). 322 // WebKit has a special node (a composition node) for input method to change 323 // its text without affecting any other DOM nodes. When the input method 324 // (attached to the browser) updates its text, the browser sends IPC messages 325 // to update the composition node of the renderer. 326 // (Read the comments of each function for its detail.) 327 328 // Sets the text of the composition node. 329 // This function can also update the cursor position and mark the specified 330 // range in the composition node. 331 // A browser should call this function: 332 // * when it receives a WM_IME_COMPOSITION message with a GCS_COMPSTR flag 333 // (on Windows); 334 // * when it receives a "preedit_changed" signal of GtkIMContext (on Linux); 335 // * when markedText of NSTextInput is called (on Mac). 336 void ImeSetComposition( 337 const base::string16& text, 338 const std::vector<blink::WebCompositionUnderline>& underlines, 339 int selection_start, 340 int selection_end); 341 342 // Finishes an ongoing composition with the specified text. 343 // A browser should call this function: 344 // * when it receives a WM_IME_COMPOSITION message with a GCS_RESULTSTR flag 345 // (on Windows); 346 // * when it receives a "commit" signal of GtkIMContext (on Linux); 347 // * when insertText of NSTextInput is called (on Mac). 348 void ImeConfirmComposition(const base::string16& text, 349 const gfx::Range& replacement_range, 350 bool keep_selection); 351 352 // Cancels an ongoing composition. 353 void ImeCancelComposition(); 354 355 // Deletes the current selection plus the specified number of characters 356 // before and after the selection or caret. 357 void ExtendSelectionAndDelete(size_t before, size_t after); 358 359 // This is for derived classes to give us access to the resizer rect. 360 // And to also expose it to the RenderWidgetHostView. 361 virtual gfx::Rect GetRootWindowResizerRect() const; 362 363 bool ignore_input_events() const { 364 return ignore_input_events_; 365 } 366 367 bool input_method_active() const { 368 return input_method_active_; 369 } 370 371 // Whether forwarded WebInputEvents should be ignored. True if either 372 // |ignore_input_events_| or |process_->IgnoreInputEvents()| is true. 373 bool IgnoreInputEvents() const; 374 375 // Event queries delegated to the |input_router_|. 376 bool ShouldForwardTouchEvent() const; 377 378 bool has_touch_handler() const { return has_touch_handler_; } 379 380 // Notification that the user has made some kind of input that could 381 // perform an action. See OnUserGesture for more details. 382 void StartUserGesture(); 383 384 // Set the RenderView background. 385 void SetBackground(const SkBitmap& background); 386 387 // Notifies the renderer that the next key event is bound to one or more 388 // pre-defined edit commands 389 void SetEditCommandsForNextKeyEvent( 390 const std::vector<EditCommand>& commands); 391 392 // Gets the accessibility mode. 393 AccessibilityMode accessibility_mode() const { 394 return accessibility_mode_; 395 } 396 397 // Send a message to the renderer process to change the accessibility mode. 398 void SetAccessibilityMode(AccessibilityMode mode); 399 400 // Relay a request from assistive technology to perform the default action 401 // on a given node. 402 void AccessibilityDoDefaultAction(int object_id); 403 404 // Relay a request from assistive technology to set focus to a given node. 405 void AccessibilitySetFocus(int object_id); 406 407 // Relay a request from assistive technology to make a given object 408 // visible by scrolling as many scrollable containers as necessary. 409 // In addition, if it's not possible to make the entire object visible, 410 // scroll so that the |subfocus| rect is visible at least. The subfocus 411 // rect is in local coordinates of the object itself. 412 void AccessibilityScrollToMakeVisible( 413 int acc_obj_id, gfx::Rect subfocus); 414 415 // Relay a request from assistive technology to move a given object 416 // to a specific location, in the WebContents area coordinate space, i.e. 417 // (0, 0) is the top-left corner of the WebContents. 418 void AccessibilityScrollToPoint(int acc_obj_id, gfx::Point point); 419 420 // Relay a request from assistive technology to set text selection. 421 void AccessibilitySetTextSelection( 422 int acc_obj_id, int start_offset, int end_offset); 423 424 // Kill the renderer because we got a fatal accessibility error. 425 void FatalAccessibilityTreeError(); 426 427 #if defined(OS_WIN) && defined(USE_AURA) 428 void SetParentNativeViewAccessible( 429 gfx::NativeViewAccessible accessible_parent); 430 gfx::NativeViewAccessible GetParentNativeViewAccessible() const; 431 #endif 432 433 // Executes the edit command on the RenderView. 434 void ExecuteEditCommand(const std::string& command, 435 const std::string& value); 436 437 // Tells the renderer to scroll the currently focused node into rect only if 438 // the currently focused node is a Text node (textfield, text area or content 439 // editable divs). 440 void ScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect); 441 442 // Requests the renderer to select the region between two points. 443 void SelectRange(const gfx::Point& start, const gfx::Point& end); 444 445 // Requests the renderer to move the caret selection towards the point. 446 void MoveCaret(const gfx::Point& point); 447 448 // Called when the reponse to a pending mouse lock request has arrived. 449 // Returns true if |allowed| is true and the mouse has been successfully 450 // locked. 451 bool GotResponseToLockMouseRequest(bool allowed); 452 453 // Tells the RenderWidget about the latest vsync parameters. 454 // Note: Make sure the timebase was obtained using 455 // base::TimeTicks::HighResNow. Using the non-high res timer will result in 456 // incorrect synchronization across processes. 457 virtual void UpdateVSyncParameters(base::TimeTicks timebase, 458 base::TimeDelta interval); 459 460 // Called by the view in response to AcceleratedSurfaceBuffersSwapped or 461 // AcceleratedSurfacePostSubBuffer. 462 static void AcknowledgeBufferPresent( 463 int32 route_id, 464 int gpu_host_id, 465 const AcceleratedSurfaceMsg_BufferPresented_Params& params); 466 467 // Called by the view in response to OnSwapCompositorFrame. 468 static void SendSwapCompositorFrameAck( 469 int32 route_id, 470 uint32 output_surface_id, 471 int renderer_host_id, 472 const cc::CompositorFrameAck& ack); 473 474 // Called by the view to return resources to the compositor. 475 static void SendReclaimCompositorResources(int32 route_id, 476 uint32 output_surface_id, 477 int renderer_host_id, 478 const cc::CompositorFrameAck& ack); 479 480 // Called by the view in response to AcceleratedSurfaceBuffersSwapped for 481 // platforms that support deferred GPU process descheduling. This does 482 // nothing if the compositor thread is enabled. 483 // TODO(jbates) Once the compositor thread is always on, this can be removed. 484 void AcknowledgeSwapBuffersToRenderer(); 485 486 bool is_threaded_compositing_enabled() const { 487 return is_threaded_compositing_enabled_; 488 } 489 490 #if defined(USE_AURA) 491 // Called by the view when the parent changes. If a parent isn't available, 492 // NULL is used. 493 void ParentChanged(gfx::NativeViewId new_parent); 494 #endif 495 496 // Signals that the compositing surface was updated, e.g. after a lost context 497 // event. 498 void CompositingSurfaceUpdated(); 499 500 void set_allow_privileged_mouse_lock(bool allow) { 501 allow_privileged_mouse_lock_ = allow; 502 } 503 504 // Resets state variables related to tracking pending size and painting. 505 // 506 // We need to reset these flags when we want to repaint the contents of 507 // browser plugin in this RWH. Resetting these flags will ensure we ignore 508 // any previous pending acks that are not relevant upon repaint. 509 void ResetSizeAndRepaintPendingFlags(); 510 511 void DetachDelegate(); 512 513 // Update the renderer's cache of the screen rect of the view and window. 514 void SendScreenRects(); 515 516 OverscrollController* overscroll_controller() const { 517 return overscroll_controller_.get(); 518 } 519 520 // Sets whether the overscroll controller should be enabled for this page. 521 void SetOverscrollControllerEnabled(bool enabled); 522 523 // Suppreses future char events until a keydown. See 524 // suppress_next_char_events_. 525 void SuppressNextCharEvents(); 526 527 // Called by RenderWidgetHostView in response to OnSetNeedsFlushInput. 528 void FlushInput(); 529 530 // InputRouterClient 531 virtual void SetNeedsFlush() OVERRIDE; 532 533 // Indicates whether the renderer drives the RenderWidgetHosts's size or the 534 // other way around. 535 bool should_auto_resize() { return should_auto_resize_; } 536 537 void ComputeTouchLatency(const ui::LatencyInfo& latency_info); 538 void FrameSwapped(const ui::LatencyInfo& latency_info); 539 void DidReceiveRendererFrame(); 540 541 // Returns the ID that uniquely describes this component to the latency 542 // subsystem. 543 int64 GetLatencyComponentId(); 544 545 static void CompositorFrameDrawn(const ui::LatencyInfo& latency_info); 546 547 // Don't check whether we expected a resize ack during layout tests. 548 static void DisableResizeAckCheckForTesting(); 549 550 protected: 551 virtual RenderWidgetHostImpl* AsRenderWidgetHostImpl() OVERRIDE; 552 553 // Create a LatencyInfo struct with INPUT_EVENT_LATENCY_RWH_COMPONENT 554 // component if it is not already in |original|. And if |original| is 555 // not NULL, it is also merged into the resulting LatencyInfo. 556 ui::LatencyInfo CreateRWHLatencyInfoIfNotExist( 557 const ui::LatencyInfo* original, blink::WebInputEvent::Type type); 558 559 // Called when we receive a notification indicating that the renderer 560 // process has gone. This will reset our state so that our state will be 561 // consistent if a new renderer is created. 562 void RendererExited(base::TerminationStatus status, int exit_code); 563 564 // Retrieves an id the renderer can use to refer to its view. 565 // This is used for various IPC messages, including plugins. 566 gfx::NativeViewId GetNativeViewId() const; 567 568 // Retrieves an id for the surface that the renderer can draw to 569 // when accelerated compositing is enabled. 570 gfx::GLSurfaceHandle GetCompositingSurface(); 571 572 // --------------------------------------------------------------------------- 573 // The following methods are overridden by RenderViewHost to send upwards to 574 // its delegate. 575 576 // Called when a mousewheel event was not processed by the renderer. 577 virtual void UnhandledWheelEvent(const blink::WebMouseWheelEvent& event) {} 578 579 // Notification that the user has made some kind of input that could 580 // perform an action. The gestures that count are 1) any mouse down 581 // event and 2) enter or space key presses. 582 virtual void OnUserGesture() {} 583 584 // Callbacks for notification when the renderer becomes unresponsive to user 585 // input events, and subsequently responsive again. 586 virtual void NotifyRendererUnresponsive() {} 587 virtual void NotifyRendererResponsive() {} 588 589 // Called when auto-resize resulted in the renderer size changing. 590 virtual void OnRenderAutoResized(const gfx::Size& new_size) {} 591 592 // --------------------------------------------------------------------------- 593 594 // RenderViewHost overrides this method to impose further restrictions on when 595 // to allow mouse lock. 596 // Once the request is approved or rejected, GotResponseToLockMouseRequest() 597 // will be called. 598 virtual void RequestToLockMouse(bool user_gesture, 599 bool last_unlocked_by_target); 600 601 void RejectMouseLockOrUnlockIfNecessary(); 602 bool IsMouseLocked() const; 603 604 // RenderViewHost overrides this method to report when in fullscreen mode. 605 virtual bool IsFullscreen() const; 606 607 // Indicates if the render widget host should track the render widget's size 608 // as opposed to visa versa. 609 void SetShouldAutoResize(bool enable); 610 611 // Expose increment/decrement of the in-flight event count, so 612 // RenderViewHostImpl can account for in-flight beforeunload/unload events. 613 int increment_in_flight_event_count() { return ++in_flight_event_count_; } 614 int decrement_in_flight_event_count() { return --in_flight_event_count_; } 615 616 // Returns whether an overscroll gesture is in progress. 617 bool IsInOverscrollGesture() const; 618 619 // The View associated with the RenderViewHost. The lifetime of this object 620 // is associated with the lifetime of the Render process. If the Renderer 621 // crashes, its View is destroyed and this pointer becomes NULL, even though 622 // render_view_host_ lives on to load another URL (creating a new View while 623 // doing so). 624 RenderWidgetHostViewPort* view_; 625 626 // true if a renderer has once been valid. We use this flag to display a sad 627 // tab only when we lose our renderer and not if a paint occurs during 628 // initialization. 629 bool renderer_initialized_; 630 631 // This value indicates how long to wait before we consider a renderer hung. 632 int hung_renderer_delay_ms_; 633 634 private: 635 friend class MockRenderWidgetHost; 636 637 // Tell this object to destroy itself. 638 void Destroy(); 639 640 // Called by |hang_timeout_monitor_| on delayed response from the renderer. 641 void RendererIsUnresponsive(); 642 643 // Called if we know the renderer is responsive. When we currently think the 644 // renderer is unresponsive, this will clear that state and call 645 // NotifyRendererResponsive. 646 void RendererIsResponsive(); 647 648 // IPC message handlers 649 void OnRenderViewReady(); 650 void OnRenderProcessGone(int status, int error_code); 651 void OnClose(); 652 void OnUpdateScreenRectsAck(); 653 void OnRequestMove(const gfx::Rect& pos); 654 void OnSetTooltipText(const base::string16& tooltip_text, 655 blink::WebTextDirection text_direction_hint); 656 void OnPaintAtSizeAck(int tag, const gfx::Size& size); 657 #if defined(OS_MACOSX) 658 void OnCompositorSurfaceBuffersSwapped( 659 const ViewHostMsg_CompositorSurfaceBuffersSwapped_Params& params); 660 #endif 661 bool OnSwapCompositorFrame(const IPC::Message& message); 662 void OnOverscrolled(gfx::Vector2dF accumulated_overscroll, 663 gfx::Vector2dF current_fling_velocity); 664 void OnUpdateRect(const ViewHostMsg_UpdateRect_Params& params); 665 void OnUpdateIsDelayed(); 666 void OnQueueSyntheticGesture(const SyntheticGesturePacket& gesture_packet); 667 virtual void OnFocus(); 668 virtual void OnBlur(); 669 void OnSetCursor(const WebCursor& cursor); 670 void OnTextInputTypeChanged(ui::TextInputType type, 671 ui::TextInputMode input_mode, 672 bool can_compose_inline); 673 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA) 674 void OnImeCompositionRangeChanged( 675 const gfx::Range& range, 676 const std::vector<gfx::Rect>& character_bounds); 677 #endif 678 void OnImeCancelComposition(); 679 void OnDidActivateAcceleratedCompositing(bool activated); 680 void OnLockMouse(bool user_gesture, 681 bool last_unlocked_by_target, 682 bool privileged); 683 void OnUnlockMouse(); 684 void OnShowDisambiguationPopup(const gfx::Rect& rect, 685 const gfx::Size& size, 686 const TransportDIB::Id& id); 687 #if defined(OS_WIN) 688 void OnWindowlessPluginDummyWindowCreated( 689 gfx::NativeViewId dummy_activation_window); 690 void OnWindowlessPluginDummyWindowDestroyed( 691 gfx::NativeViewId dummy_activation_window); 692 #endif 693 void OnSnapshot(bool success, const SkBitmap& bitmap); 694 695 // Called (either immediately or asynchronously) after we're done with our 696 // BackingStore and can send an ACK to the renderer so it can paint onto it 697 // again. 698 void DidUpdateBackingStore(const ViewHostMsg_UpdateRect_Params& params, 699 const base::TimeTicks& paint_start); 700 701 // Paints the given bitmap to the current backing store at the given 702 // location. Returns true if the passed callback was asynchronously 703 // scheduled in the future (and thus the caller must manually synchronously 704 // call the callback function). 705 bool PaintBackingStoreRect(TransportDIB::Id bitmap, 706 const gfx::Rect& bitmap_rect, 707 const std::vector<gfx::Rect>& copy_rects, 708 const gfx::Size& view_size, 709 float scale_factor, 710 const base::Closure& completion_callback); 711 712 // Scrolls the given |clip_rect| in the backing by the given dx/dy amount. The 713 // |dib| and its corresponding location |bitmap_rect| in the backing store 714 // is the newly painted pixels by the renderer. 715 void ScrollBackingStoreRect(const gfx::Vector2d& delta, 716 const gfx::Rect& clip_rect, 717 const gfx::Size& view_size); 718 719 // Give key press listeners a chance to handle this key press. This allow 720 // widgets that don't have focus to still handle key presses. 721 bool KeyPressListenersHandleEvent(const NativeWebKeyboardEvent& event); 722 723 // InputRouterClient 724 virtual InputEventAckState FilterInputEvent( 725 const blink::WebInputEvent& event, 726 const ui::LatencyInfo& latency_info) OVERRIDE; 727 virtual void IncrementInFlightEventCount() OVERRIDE; 728 virtual void DecrementInFlightEventCount() OVERRIDE; 729 virtual void OnHasTouchEventHandlers(bool has_handlers) OVERRIDE; 730 virtual OverscrollController* GetOverscrollController() const OVERRIDE; 731 virtual void DidFlush() OVERRIDE; 732 733 // InputAckHandler 734 virtual void OnKeyboardEventAck(const NativeWebKeyboardEvent& event, 735 InputEventAckState ack_result) OVERRIDE; 736 virtual void OnWheelEventAck(const MouseWheelEventWithLatencyInfo& event, 737 InputEventAckState ack_result) OVERRIDE; 738 virtual void OnTouchEventAck(const TouchEventWithLatencyInfo& event, 739 InputEventAckState ack_result) OVERRIDE; 740 virtual void OnGestureEventAck(const GestureEventWithLatencyInfo& event, 741 InputEventAckState ack_result) OVERRIDE; 742 virtual void OnUnexpectedEventAck(UnexpectedEventAckType type) OVERRIDE; 743 744 // Called when there is a new auto resize (using a post to avoid a stack 745 // which may get in recursive loops). 746 void DelayedAutoResized(); 747 748 void WindowSnapshotReachedScreen(int snapshot_id); 749 750 // Our delegate, which wants to know mainly about keyboard events. 751 // It will remain non-NULL until DetachDelegate() is called. 752 RenderWidgetHostDelegate* delegate_; 753 754 // Created during construction but initialized during Init*(). Therefore, it 755 // is guaranteed never to be NULL, but its channel may be NULL if the 756 // renderer crashed, so you must always check that. 757 RenderProcessHost* process_; 758 759 // The ID of the corresponding object in the Renderer Instance. 760 int routing_id_; 761 762 // The ID of the surface corresponding to this render widget. 763 int surface_id_; 764 765 // Indicates whether a page is loading or not. 766 bool is_loading_; 767 768 // Indicates whether a page is hidden or not. 769 bool is_hidden_; 770 771 // Indicates whether a page is fullscreen or not. 772 bool is_fullscreen_; 773 774 // True when a page is rendered directly via the GPU process. 775 bool is_accelerated_compositing_active_; 776 777 // True if threaded compositing is enabled on this view. 778 bool is_threaded_compositing_enabled_; 779 780 // Set if we are waiting for a repaint ack for the view. 781 bool repaint_ack_pending_; 782 783 // True when waiting for RESIZE_ACK. 784 bool resize_ack_pending_; 785 786 // Cached copy of the screen info so that it doesn't need to be updated every 787 // time the window is resized. 788 scoped_ptr<blink::WebScreenInfo> screen_info_; 789 790 // Set if screen_info_ may have changed and should be recomputed and force a 791 // resize message. 792 bool screen_info_out_of_date_; 793 794 // The current size of the RenderWidget. 795 gfx::Size current_size_; 796 797 // The size of the view's backing surface in non-DPI-adjusted pixels. 798 gfx::Size physical_backing_size_; 799 800 // The height of the physical backing surface that is overdrawn opaquely in 801 // the browser, for example by an on-screen-keyboard (in DPI-adjusted pixels). 802 float overdraw_bottom_height_; 803 804 // The size we last sent as requested size to the renderer. |current_size_| 805 // is only updated once the resize message has been ack'd. This on the other 806 // hand is updated when the resize message is sent. This is very similar to 807 // |resize_ack_pending_|, but the latter is not set if the new size has width 808 // or height zero, which is why we need this too. 809 gfx::Size last_requested_size_; 810 811 // The next auto resize to send. 812 gfx::Size new_auto_size_; 813 814 // True if the render widget host should track the render widget's size as 815 // opposed to visa versa. 816 bool should_auto_resize_; 817 818 bool waiting_for_screen_rects_ack_; 819 gfx::Rect last_view_screen_rect_; 820 gfx::Rect last_window_screen_rect_; 821 822 AccessibilityMode accessibility_mode_; 823 824 // Keyboard event listeners. 825 std::vector<KeyPressEventCallback> key_press_event_callbacks_; 826 827 // Mouse event callbacks. 828 std::vector<MouseEventCallback> mouse_event_callbacks_; 829 830 // If true, then we should repaint when restoring even if we have a 831 // backingstore. This flag is set to true if we receive a paint message 832 // while is_hidden_ to true. Even though we tell the render widget to hide 833 // itself, a paint message could already be in flight at that point. 834 bool needs_repainting_on_restore_; 835 836 // This is true if the renderer is currently unresponsive. 837 bool is_unresponsive_; 838 839 // The following value indicates a time in the future when we would consider 840 // the renderer hung if it does not generate an appropriate response message. 841 base::Time time_when_considered_hung_; 842 843 // This value denotes the number of input events yet to be acknowledged 844 // by the renderer. 845 int in_flight_event_count_; 846 847 // This timer runs to check if time_when_considered_hung_ has past. 848 base::OneShotTimer<RenderWidgetHostImpl> hung_renderer_timer_; 849 850 // Flag to detect recursive calls to GetBackingStore(). 851 bool in_get_backing_store_; 852 853 // Flag to trigger the GetBackingStore method to abort early. 854 bool abort_get_backing_store_; 855 856 // Set when we call DidPaintRect/DidScrollRect on the view. 857 bool view_being_painted_; 858 859 // Used for UMA histogram logging to measure the time for a repaint view 860 // operation to finish. 861 base::TimeTicks repaint_start_time_; 862 863 // Set to true if we shouldn't send input events from the render widget. 864 bool ignore_input_events_; 865 866 // Indicates whether IME is active. 867 bool input_method_active_; 868 869 // Set when we update the text direction of the selected input element. 870 bool text_direction_updated_; 871 blink::WebTextDirection text_direction_; 872 873 // Set when we cancel updating the text direction. 874 // This flag also ignores succeeding update requests until we call 875 // NotifyTextDirection(). 876 bool text_direction_canceled_; 877 878 // Indicates if the next sequence of Char events should be suppressed or not. 879 // System may translate a RawKeyDown event into zero or more Char events, 880 // usually we send them to the renderer directly in sequence. However, If a 881 // RawKeyDown event was not handled by the renderer but was handled by 882 // our UnhandledKeyboardEvent() method, e.g. as an accelerator key, then we 883 // shall not send the following sequence of Char events, which was generated 884 // by this RawKeyDown event, to the renderer. Otherwise the renderer may 885 // handle the Char events and cause unexpected behavior. 886 // For example, pressing alt-2 may let the browser switch to the second tab, 887 // but the Char event generated by alt-2 may also activate a HTML element 888 // if its accesskey happens to be "2", then the user may get confused when 889 // switching back to the original tab, because the content may already be 890 // changed. 891 bool suppress_next_char_events_; 892 893 // The last scroll offset of the render widget. 894 gfx::Vector2d last_scroll_offset_; 895 896 bool pending_mouse_lock_request_; 897 bool allow_privileged_mouse_lock_; 898 899 // Keeps track of whether the webpage has any touch event handler. If it does, 900 // then touch events are sent to the renderer. Otherwise, the touch events are 901 // not sent to the renderer. 902 bool has_touch_handler_; 903 904 base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_; 905 906 scoped_ptr<SyntheticGestureController> synthetic_gesture_controller_; 907 908 // Receives and handles all input events. 909 scoped_ptr<InputRouter> input_router_; 910 911 scoped_ptr<OverscrollController> overscroll_controller_; 912 913 scoped_ptr<TimeoutMonitor> hang_monitor_timeout_; 914 915 #if defined(OS_WIN) 916 std::list<HWND> dummy_windows_for_activation_; 917 #endif 918 919 // List of callbacks for pending snapshot requests to the renderer. 920 std::queue<base::Callback<void(bool, const SkBitmap&)> > pending_snapshots_; 921 922 int64 last_input_number_; 923 924 BrowserRenderingStats rendering_stats_; 925 926 DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl); 927 }; 928 929 } // namespace content 930 931 #endif // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_ 932