Return the WebViewFrameWidget in RenderWidget::webwidget() if there

content/renderer/render_widget.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 1053 matching lines @@
   WebSize visual_viewport_size;
 
   if (IsUseZoomForDSFEnabled()) {
     visual_viewport_size = gfx::ScaleToCeiledSize(
         params.visible_viewport_size,
         GetOriginalDeviceScaleFactor());
   } else {
     visual_viewport_size = visible_viewport_size_;
   }
 
-  webwidget()->resizeVisualViewport(visual_viewport_size);
+  GetWebWidget()->resizeVisualViewport(visual_viewport_size);
 
   // When resizing, we want to wait to paint before ACK'ing the resize.  This
   // ensures that we only resize as fast as we can paint.  We only need to
   // send an ACK if we are resized to a non-empty rect.
   if (params.new_size.IsEmpty() || params.physical_backing_size.IsEmpty()) {
     // In this case there is no paint/composite and therefore no
     // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
     // ack through a fake ViewHostMsg_UpdateRect or a different message.
     DCHECK(!params.needs_resize_ack);
   }
@@ skipping 52 matching lines @@
 
 void RenderWidget::WillCloseLayerTreeView() {
   if (host_closing_)
     return;
 
   // Prevent new compositors or output surfaces from being created.
   host_closing_ = true;
 
   // Always send this notification to prevent new layer tree views from
   // being created, even if one hasn't been created yet.
-  if (webwidget_)
-    webwidget_->willCloseLayerTreeView();
+  if (GetWebWidget())
+    GetWebWidget()->willCloseLayerTreeView();
 }
 
 blink::WebLayerTreeView* RenderWidget::layerTreeView() {
   return compositor_.get();
 }
 
 void RenderWidget::didMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
   if (layout_type == blink::WebMeaningfulLayout::VisuallyNonEmpty) {
     QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_),
                  MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
@@ skipping 215 matching lines @@
     const gfx::Range& replacement_range,
     int selection_start, int selection_end) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeSetComposition(
         text, underlines, selection_start, selection_end);
     return;
   }
 #endif
   if (replacement_range.IsValid()) {
-    webwidget_->applyReplacementRange(replacement_range.start(),
-                                      replacement_range.length());
+    GetWebWidget()->applyReplacementRange(replacement_range.start(),
+                                          replacement_range.length());
   }
 
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
-  if (!webwidget_->setComposition(
-      text, WebVector<WebCompositionUnderline>(underlines),
-      selection_start, selection_end)) {
+  if (!GetWebWidget()->setComposition(
+          text, WebVector<WebCompositionUnderline>(underlines), selection_start,
+          selection_end)) {
     // If we failed to set the composition text, then we need to let the browser
     // process to cancel the input method's ongoing composition session, to make
     // sure we are in a consistent state.
     Send(new InputHostMsg_ImeCancelComposition(routing_id()));
   }
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeConfirmComposition(const base::string16& text,
                                            const gfx::Range& replacement_range,
                                            bool keep_selection) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeConfirmComposition(
         text, replacement_range, keep_selection);
     return;
   }
 #endif
   if (replacement_range.IsValid()) {
-    webwidget_->applyReplacementRange(replacement_range.start(),
-                                      replacement_range.length());
+    GetWebWidget()->applyReplacementRange(replacement_range.start(),
+                                          replacement_range.length());
   }
 
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
   input_handler_->set_handling_input_event(true);
   if (text.length())
-    webwidget_->confirmComposition(text);
+    GetWebWidget()->confirmComposition(text);
   else if (keep_selection)
-    webwidget_->confirmComposition(WebWidget::KeepSelection);
+    GetWebWidget()->confirmComposition(WebWidget::KeepSelection);
   else
-    webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
+    GetWebWidget()->confirmComposition(WebWidget::DoNotKeepSelection);
   input_handler_->set_handling_input_event(false);
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnDeviceScaleFactorChanged() {
   if (!compositor_)
     return;
   if (IsUseZoomForDSFEnabled())
     compositor_->SetPaintedDeviceScaleFactor(GetOriginalDeviceScaleFactor());
   else
     compositor_->setDeviceScaleFactor(device_scale_factor_);
 }
 
 void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
   // During shutdown we can just ignore this message.
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
 
   // Even if the browser provides an empty damage rect, it's still expecting to
   // receive a repaint ack so just damage the entire widget bounds.
   if (size_to_paint.IsEmpty()) {
     size_to_paint = size_;
   }
 
   set_next_paint_is_repaint_ack();
   if (compositor_)
     compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
 }
 
 void RenderWidget::OnSyntheticGestureCompleted() {
   DCHECK(!pending_synthetic_gesture_callbacks_.empty());
 
   pending_synthetic_gesture_callbacks_.front().Run();
   pending_synthetic_gesture_callbacks_.pop();
 }
 
 void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
-  webwidget_->setTextDirection(direction);
+  GetWebWidget()->setTextDirection(direction);
 }
 
 void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                                        const gfx::Rect& window_screen_rect) {
   if (screen_metrics_emulator_) {
     screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
                                                   window_screen_rect);
   } else {
     SetScreenRects(view_screen_rect, window_screen_rect);
   }
@@ skipping 21 matching lines @@
 
 void RenderWidget::showImeIfNeeded() {
   OnShowImeIfNeeded();
 }
 
 ui::TextInputType RenderWidget::GetTextInputType() {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     return focused_pepper_plugin_->text_input_type();
 #endif
-  if (webwidget_)
-    return WebKitToUiTextInputType(webwidget_->textInputType());
+  if (GetWebWidget())
+    return WebKitToUiTextInputType(GetWebWidget()->textInputType());
   return ui::TEXT_INPUT_TYPE_NONE;
 }
 
 void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
   if (!monitor_composition_info_ && !immediate_request)
     return;  // Do not calculate composition info if not requested.
 
   TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
   gfx::Range range;
   std::vector<gfx::Rect> character_bounds;
@@ skipping 71 matching lines @@
 void RenderWidget::OnRequestCompositionUpdate(bool immediate_request,
                                               bool monitor_request) {
   monitor_composition_info_ = monitor_request;
   if (!immediate_request)
     return;
   UpdateCompositionInfo(true /* immediate request */);
 }
 
 bool RenderWidget::ShouldHandleImeEvent() {
 #if defined(OS_ANDROID)
-  if (!webwidget_)
+  if (!GetWebWidget())
     return false;
   if (IsUsingImeThread())
     return true;
 
   // We cannot handle IME events if there is any chance that the event we are
   // receiving here from the browser is based on the state that is different
   // from our current one as indicated by |text_input_info_|.
   // The states the browser might be in are:
   // text_input_info_history_[0] - current state ack'd by browser
   // text_input_info_history_[1...N] - pending state changes
   for (size_t i = 0u; i < text_input_info_history_.size() - 1u; ++i) {
     if (text_input_info_history_[i] != text_input_info_)
       return false;
   }
   return true;
 #else
-  return !!webwidget_;
+  return !!GetWebWidget();
 #endif
 }
 
 void RenderWidget::OnSetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
   device_scale_factor_ = device_scale_factor;
 
   OnDeviceScaleFactorChanged();
@@ skipping 35 matching lines @@
   if (is_hidden_)
     RenderThreadImpl::current()->WidgetHidden();
   else
     RenderThreadImpl::current()->WidgetRestored();
 
   if (render_widget_scheduling_state_)
     render_widget_scheduling_state_->SetHidden(hidden);
 }
 
 void RenderWidget::DidToggleFullscreen() {
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
 
   if (is_fullscreen_granted_) {
-    webwidget_->didEnterFullscreen();
+    GetWebWidget()->didEnterFullscreen();
   } else {
-    webwidget_->didExitFullscreen();
+    GetWebWidget()->didExitFullscreen();
   }
 }
 
 bool RenderWidget::next_paint_is_resize_ack() const {
   return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
 }
 
 void RenderWidget::set_next_paint_is_resize_ack() {
   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
 }
@@ skipping 50 matching lines @@
     // after Pepper API equips features related to surrounding text retrieval.
     blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
     convertViewportToWindow(&caret);
     *focus = caret;
     *anchor = caret;
     return;
   }
 #endif
   WebRect focus_webrect;
   WebRect anchor_webrect;
-  webwidget_->selectionBounds(focus_webrect, anchor_webrect);
+  GetWebWidget()->selectionBounds(focus_webrect, anchor_webrect);
   convertViewportToWindow(&focus_webrect);
   convertViewportToWindow(&anchor_webrect);
   *focus = focus_webrect;
   *anchor = anchor_webrect;
 }
 
 void RenderWidget::UpdateSelectionBounds() {
   TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
   if (ime_event_guard_)
     return;
 
 #if defined(USE_AURA)
   // TODO(mohsen): For now, always send explicit selection IPC notifications for
   // Aura beucause composited selection updates are not working for webview tags
   // which regresses IME inside webview. Remove this when composited selection
   // updates are fixed for webviews. See, http://crbug.com/510568.
   bool send_ipc = true;
 #else
   // With composited selection updates, the selection bounds will be reported
   // directly by the compositor, in which case explicit IPC selection
   // notifications should be suppressed.
   bool send_ipc =
       !blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled();
 #endif
   if (send_ipc) {
     ViewHostMsg_SelectionBounds_Params params;
     GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
     if (selection_anchor_rect_ != params.anchor_rect ||
         selection_focus_rect_ != params.focus_rect) {
       selection_anchor_rect_ = params.anchor_rect;
       selection_focus_rect_ = params.focus_rect;
-      webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
-      params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
+      GetWebWidget()->selectionTextDirection(params.focus_dir,
+                                             params.anchor_dir);
+      params.is_anchor_first = GetWebWidget()->isSelectionAnchorFirst();
       Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
     }
   }
 
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::SetDeviceColorProfileForTesting(
     const std::vector<char>& color_profile) {
   SetDeviceColorProfile(color_profile);
@@ skipping 57 matching lines @@
 void RenderWidget::GetCompositionCharacterBounds(
     std::vector<gfx::Rect>* bounds) {
   DCHECK(bounds);
   bounds->clear();
 
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     return;
 #endif
 
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
   blink::WebVector<blink::WebRect> bounds_from_blink;
-  if (!webwidget_->getCompositionCharacterBounds(bounds_from_blink))
+  if (!GetWebWidget()->getCompositionCharacterBounds(bounds_from_blink))
     return;
 
   for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
     convertViewportToWindow(&bounds_from_blink[i]);
     bounds->push_back(bounds_from_blink[i]);
   }
 }
 
 void RenderWidget::GetCompositionRange(gfx::Range* range) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     return;
 #endif
   size_t location, length;
-  if (webwidget_->compositionRange(&location, &length)) {
+  if (GetWebWidget()->compositionRange(&location, &length)) {
     range->set_start(location);
     range->set_end(location + length);
   } else {
     WebRange web_range = webwidget_->caretOrSelectionRange();
     range->set_start(web_range.startOffset());
     range->set_end(web_range.endOffset());
   }
 }
 
 bool RenderWidget::ShouldUpdateCompositionInfo(
@@ skipping 22 matching lines @@
   return screen_info_;
 }
 
 void RenderWidget::resetInputMethod() {
   ImeEventGuard guard(this);
   // If the last text input type is not None, then we should finish any
   // ongoing composition regardless of the new text input type.
   if (text_input_info_.type != blink::WebTextInputTypeNone) {
     // If a composition text exists, then we need to let the browser process
     // to cancel the input method's ongoing composition session.
-    if (webwidget_->confirmComposition())
+    if (GetWebWidget()->confirmComposition())
       Send(new InputHostMsg_ImeCancelComposition(routing_id()));
   }
 
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 #if defined(OS_ANDROID)
 void RenderWidget::showUnhandledTapUIIfNeeded(
     const WebPoint& tapped_position,
     const WebNode& tapped_node,
@@ skipping 11 matching lines @@
 
 void RenderWidget::didHandleGestureEvent(
     const WebGestureEvent& event,
     bool event_cancelled) {
 #if defined(OS_ANDROID) || defined(USE_AURA)
   if (event_cancelled)
     return;
   if (event.type == WebInputEvent::GestureTap) {
     UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
   } else if (event.type == WebInputEvent::GestureLongPress) {
-    DCHECK(webwidget_);
-    if (webwidget_->textInputInfo().value.isEmpty())
+    DCHECK(GetWebWidget());
+    if (GetWebWidget()->textInputInfo().value.isEmpty())
       UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
     else
       UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
   }
 #endif
 }
 
 void RenderWidget::didOverscroll(
     const blink::WebFloatSize& overscrollDelta,
     const blink::WebFloatSize& accumulatedOverscroll,
@@ skipping 117 matching lines @@
 
 void RenderWidget::requestPointerUnlock() {
   mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
 }
 
 bool RenderWidget::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
+blink::WebWidget* RenderWidget::GetWebWidget() const {
+  return webwidget_;
+}
+
 }  // namespace content