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 204 matching lines @@
 // RenderWidget ---------------------------------------------------------------
 
 RenderWidget::RenderWidget(CompositorDependencies* compositor_deps,
                            blink::WebPopupType popup_type,
                            const ScreenInfo& screen_info,
                            bool swapped_out,
                            bool hidden,
                            bool never_visible)
     : routing_id_(MSG_ROUTING_NONE),
       compositor_deps_(compositor_deps),
-      webwidget_(nullptr),
+      webwidget_internal_(nullptr),
       owner_delegate_(nullptr),
       opener_id_(MSG_ROUTING_NONE),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       compositor_never_visible_(never_visible),
       is_fullscreen_granted_(false),
       display_mode_(blink::WebDisplayModeUndefined),
@@ skipping 31 matching lines @@
   // In tests there may not be a RenderThreadImpl.
   if (RenderThreadImpl::current()) {
     render_widget_scheduling_state_ = RenderThreadImpl::current()
                                           ->GetRendererScheduler()
                                           ->NewRenderWidgetSchedulingState();
     render_widget_scheduling_state_->SetHidden(is_hidden_);
   }
 }
 
 RenderWidget::~RenderWidget() {
-  DCHECK(!webwidget_) << "Leaking our WebWidget!";
+  DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
 
   // If we are swapped out, we have released already.
   if (!is_swapped_out_ && RenderProcess::current())
     RenderProcess::current()->ReleaseProcess();
 }
 
 // static
 void RenderWidget::InstallCreateHook(
     CreateRenderWidgetFunction create_render_widget,
     RenderWidgetInitializedCallback render_widget_initialized) {
@@ skipping 95 matching lines @@
   if (success) {
     SetRoutingID(routing_id_);
     return true;
   }
   return false;
 }
 
 bool RenderWidget::DoInit(int32_t opener_id,
                           WebWidget* web_widget,
                           IPC::SyncMessage* create_widget_message) {
-  DCHECK(!webwidget_);
+  DCHECK(!webwidget_internal_);
 
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
-  webwidget_ = web_widget;
-  webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
+  webwidget_internal_ = web_widget;
+  webwidget_mouse_lock_target_.reset(
+      new WebWidgetLockTarget(webwidget_internal_));
   mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
 
   bool result = true;
   if (create_widget_message)
     result = RenderThread::Get()->Send(create_widget_message);
 
   if (result) {
     RenderThread::Get()->AddRoute(routing_id_, this);
     // Take a reference on behalf of the RenderThread.  This will be balanced
     // when we receive ViewMsg_Close.
@@ skipping 214 matching lines @@
 }
 
 void RenderWidget::OnDisableDeviceEmulation() {
   screen_metrics_emulator_.reset();
 }
 
 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
   if (resizer_rect_ == resizer_rect)
     return;
   resizer_rect_ = resizer_rect;
-  if (webwidget_)
-    webwidget_->didChangeWindowResizerRect();
+  if (GetWebWidget())
+    GetWebWidget()->didChangeWindowResizerRect();
 }
 
 void RenderWidget::OnWasHidden() {
   TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
   // Go into a mode where we stop generating paint and scrolling events.
   SetHidden(true);
   FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
                     WasHidden());
 }
 
 void RenderWidget::OnWasShown(bool needs_repainting,
                               const ui::LatencyInfo& latency_info) {
   TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
   // During shutdown we can just ignore this message.
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
 
   // See OnWasHidden
   SetHidden(false);
   FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
                     WasShown());
 
   if (!needs_repainting)
     return;
 
@@ skipping 20 matching lines @@
 
 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info,
                                       InputEventDispatchType dispatch_type) {
   if (!input_event)
     return;
   input_handler_->HandleInputEvent(*input_event, latency_info, dispatch_type);
 }
 
 void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
-  if (webwidget_)
-    webwidget_->setCursorVisibilityState(is_visible);
+  if (GetWebWidget())
+    GetWebWidget()->setCursorVisibilityState(is_visible);
 }
 
 void RenderWidget::OnMouseCaptureLost() {
-  if (webwidget_)
-    webwidget_->mouseCaptureLost();
+  if (GetWebWidget())
+    GetWebWidget()->mouseCaptureLost();
 }
 
 void RenderWidget::OnSetEditCommandsForNextKeyEvent(
     const EditCommands& edit_commands) {
   edit_commands_ = edit_commands;
 }
 
 void RenderWidget::OnSetFocus(bool enable) {
   has_focus_ = enable;
 
-  if (webwidget_)
-    webwidget_->setFocus(enable);
+  if (GetWebWidget())
+    GetWebWidget()->setFocus(enable);
 
   FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
                     RenderWidgetSetFocus(enable));
 }
 
 void RenderWidget::SetNeedsMainFrame() {
   RenderWidgetCompositor* rwc = compositor();
   if (!rwc)
     return;
   rwc->setNeedsBeginFrame();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetCompositorDelegate
 
 void RenderWidget::ApplyViewportDeltas(
     const gfx::Vector2dF& inner_delta,
     const gfx::Vector2dF& outer_delta,
     const gfx::Vector2dF& elastic_overscroll_delta,
     float page_scale,
     float top_controls_delta) {
-  webwidget_->applyViewportDeltas(inner_delta, outer_delta,
-                                  elastic_overscroll_delta, page_scale,
-                                  top_controls_delta);
+  GetWebWidget()->applyViewportDeltas(inner_delta, outer_delta,
+                                      elastic_overscroll_delta, page_scale,
+                                      top_controls_delta);
 }
 
 void RenderWidget::BeginMainFrame(double frame_time_sec) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   // render_thread may be NULL in tests.
   InputHandlerManager* input_handler_manager =
       render_thread ? render_thread->input_handler_manager() : NULL;
   if (input_handler_manager)
     input_handler_manager->ProcessRafAlignedInputOnMainThread(routing_id_);
 
-  webwidget_->beginFrame(frame_time_sec);
+  GetWebWidget()->beginFrame(frame_time_sec);
 }
 
 std::unique_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(
     bool fallback) {
-  DCHECK(webwidget_);
+  DCHECK(GetWebWidget());
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
   DCHECK(!compositor_never_visible_);
   return RenderThreadImpl::current()->CreateCompositorOutputSurface(
       fallback, routing_id_, frame_swap_message_queue_,
       GetURLForGraphicsContext3D());
 }
 
 void RenderWidget::DidCommitAndDrawCompositorFrame() {
   // NOTE: Tests may break if this event is renamed or moved. See
@@ skipping 63 matching lines @@
 
 void RenderWidget::OnSwapBuffersPosted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 }
 
 void RenderWidget::RequestScheduleAnimation() {
   scheduleAnimation();
 }
 
 void RenderWidget::UpdateVisualState() {
-  webwidget_->updateAllLifecyclePhases();
+  GetWebWidget()->updateAllLifecyclePhases();
 }
 
 void RenderWidget::WillBeginCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
 
   // The UpdateTextInputState can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
   UpdateSelectionBounds();
@@ skipping 91 matching lines @@
   TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
   if (ime_event_guard_) {
     // show_ime should still be effective even if it was set inside the IME
     // event guard.
     if (show_ime == ShowIme::IF_NEEDED) {
       ime_event_guard_->set_show_ime(true);
     }
     return;
   }
 
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
 
-  blink::WebTextInputInfo new_info = webwidget_->textInputInfo();
+  blink::WebTextInputInfo new_info = GetWebWidget()->textInputInfo();
 
   const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
 
   bool new_can_compose_inline = CanComposeInline();
 
   // Only sends text input params if they are changed or if the ime should be
   // shown.
   if (show_ime == ShowIme::IF_NEEDED ||
       (IsUsingImeThread() && change_source == ChangeSource::FROM_IME) ||
       (text_input_mode_ != new_mode || text_input_info_ != new_info ||
@@ skipping 52 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetScreenMetricsDelegate
 
 void RenderWidget::Redraw() {
   set_next_paint_is_resize_ack();
   if (compositor_)
     compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
 }
 
 void RenderWidget::ResizeWebWidget() {
-  webwidget_->resize(GetSizeForWebWidget());
+  GetWebWidget()->resize(GetSizeForWebWidget());
 }
 
 gfx::Size RenderWidget::GetSizeForWebWidget() const {
   if (IsUseZoomForDSFEnabled())
     return gfx::ScaleToCeiledSize(size_, GetOriginalDeviceScaleFactor());
 
   return size_;
 }
 
 void RenderWidget::Resize(const ResizeParams& params) {
   bool orientation_changed =
       screen_info_.orientation_angle != params.screen_info.orientation_angle ||
       screen_info_.orientation_type != params.screen_info.orientation_type;
 
   screen_info_ = params.screen_info;
 
   if (device_scale_factor_ != screen_info_.device_scale_factor) {
     device_scale_factor_ = screen_info_.device_scale_factor;
     OnDeviceScaleFactorChanged();
     ScheduleComposite();
   }
 
   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
     // A resize ack shouldn't be requested if we have not ACK'd the previous
     // one.
     DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack());
   }
 
   // Ignore this during shutdown.
-  if (!webwidget_)
+  if (!GetWebWidget())
     return;
 
   if (compositor_) {
     compositor_->setViewportSize(params.physical_backing_size);
     compositor_->setBottomControlsHeight(params.bottom_controls_height);
   }
 
   visible_viewport_size_ = params.visible_viewport_size;
   resizer_rect_ = params.resizer_rect;
 
@@ skipping 11 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 (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 140 matching lines @@
   SyntheticGesturePacket gesture_packet;
   gesture_packet.set_gesture_params(std::move(gesture_params));
 
   Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
 }
 
 void RenderWidget::Close() {
   screen_metrics_emulator_.reset();
   WillCloseLayerTreeView();
   compositor_.reset();
-  if (webwidget_) {
-    webwidget_->close();
-    webwidget_ = nullptr;
+  if (webwidget_internal_) {
+    webwidget_internal_->close();
+    webwidget_internal_ = nullptr;
   }
 }
 
 WebRect RenderWidget::windowRect() {
   if (pending_window_rect_count_)
     return pending_window_rect_;
 
   return view_screen_rect_;
 }
 
@@ skipping 52 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();
+    web_range = GetWebWidget()->caretOrSelectionRange();
     range->set_start(web_range.startOffset());
     range->set_end(web_range.endOffset());
   }
 }
 
 bool RenderWidget::ShouldUpdateCompositionInfo(
     const gfx::Range& range,
     const std::vector<gfx::Rect>& bounds) {
   if (composition_range_ != range)
     return true;
@@ skipping 48 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_internal_;
+}
+
 }  // namespace content