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 1051 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);

[piman, 2016/09/13 00:27:05]

Soo... why do we use GetWebWidget() sometimes, and webwidget_ some other times?
They will be different, I guess. What is the rule? Can we document it? Can we
test it?

[lfg, 2016/09/13 19:37:57]

Basically we should always prefer GetWebWidget() over webwidget_.

I thought I had switched every usage of webwidget_ to GetWebWidget(), but it
seems I forgot a few cases. I've renamed webwidget_ to webwidget_internal_ so
that nothing will be missed and added a comment to render_widget.h to avoid
using webwidget_internal_. All use cases of webwidget_ should be now using
GetWebWidget().

The only exception is the initialization and destruction, which currently
handles the lifetime of the WebView and can't be changed until we can finally
split RenderView and RenderWidget. That should happen as we continue the
refactor, but it'll still take at least a few months.

 
   // 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 (blink::WebWidget* widget = GetWebWidget())
+    widget->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(
+    GetWebWidget()->applyReplacementRange(
         WebRange(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(
+    GetWebWidget()->applyReplacementRange(
         WebRange(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
-  WebRange web_range = webwidget_->compositionRange();
+  WebRange web_range = GetWebWidget()->compositionRange();
   if (!web_range.isNull()) {
     range->set_start(web_range.startOffset());
     range->set_end(web_range.endOffset());
   } else {
     web_range = webwidget_->caretOrSelectionRange();
     range->set_start(web_range.startOffset());
     range->set_end(web_range.endOffset());
   }
 }
 
@@ skipping 53 matching lines @@
   return web_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