Use correct WebView from EventSender.

components/test_runner/event_sender.cc

 // Copyright 2014 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 "components/test_runner/event_sender.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 10 matching lines @@
 #include "components/test_runner/web_task.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "components/test_runner/web_test_proxy.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
 #include "third_party/WebKit/public/platform/WebPointerProperties.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebContextMenuData.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPagePopup.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "v8/include/v8.h"
 
 using blink::WebContextMenuData;
 using blink::WebDragData;
 using blink::WebDragOperationsMask;
 using blink::WebFloatPoint;
-using blink::WebFrame;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebInputEventResult;
 using blink::WebKeyboardEvent;
+using blink::WebLocalFrame;
 using blink::WebMenuItemInfo;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebPagePopup;
 using blink::WebPoint;
 using blink::WebPointerProperties;
 using blink::WebString;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using blink::WebVector;
@@ skipping 413 matching lines @@
 const char* kSourceDeviceStringTouchpad = "touchpad";
 const char* kSourceDeviceStringTouchscreen = "touchscreen";
 
 }  // namespace
 
 class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<EventSender> sender,
-                      blink::WebFrame* frame);
+                      blink::WebLocalFrame* frame);
 
  private:
   explicit EventSenderBindings(base::WeakPtr<EventSender> sender);
   ~EventSenderBindings() override;
 
   // gin::Wrappable:
   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
 
   // Bound methods:
@@ skipping 98 matching lines @@
 gin::WrapperInfo EventSenderBindings::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 EventSenderBindings::EventSenderBindings(base::WeakPtr<EventSender> sender)
     : sender_(sender) {
 }
 
 EventSenderBindings::~EventSenderBindings() {}
 
 // static
 void EventSenderBindings::Install(base::WeakPtr<EventSender> sender,
-                                  WebFrame* frame) {
+                                  WebLocalFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
   gin::Handle<EventSenderBindings> bindings =
       gin::CreateHandle(isolate, new EventSenderBindings(sender));
@@ skipping 577 matching lines @@
 
 WebMouseEvent::Button EventSender::last_button_type_ =
     WebMouseEvent::ButtonNone;
 
 EventSender::SavedEvent::SavedEvent()
     : type(TYPE_UNSPECIFIED),
       button_type(WebMouseEvent::ButtonNone),
       milliseconds(0),
       modifiers(0) {}
 
-EventSender::EventSender(TestInterfaces* interfaces)
-    :
-#if defined(OS_WIN)
-      wm_key_down_(0),
-      wm_key_up_(0),
-      wm_char_(0),
-      wm_dead_char_(0),
-      wm_sys_key_down_(0),
-      wm_sys_key_up_(0),
-      wm_sys_char_(0),
-      wm_sys_dead_char_(0),
-#endif
-      interfaces_(interfaces),
-      delegate_(NULL),
-      view_(NULL),
+EventSender::EventSender(WebTestProxyBase* web_test_proxy_base)
+    : web_test_proxy_base_(web_test_proxy_base),
       send_wheel_gestures_(false),
-      force_layout_on_events_(false),
-      is_drag_mode_(true),
-      touch_modifiers_(0),
-      touch_cancelable_(true),
       replaying_saved_events_(false),
-      current_drag_effects_allowed_(blink::WebDragOperationNone),
-      last_click_time_sec_(0),
-      current_drag_effect_(blink::WebDragOperationNone),
-      time_offset_ms_(0),
-      click_count_(0),

[Łukasz Anforowicz, 2016/04/21 23:01:45]

All of the removed initializers above are already handled by Reset below.

Fun fact: force_layout_on_events_ was initialized to false above, but to true in
Reset method.  I've spent 2 hours today figuring out that this was the cause of
a test failure (well, one other cause is that after my other changes Reset is no
longer called before the first test, only in-between tests;  I think this is
reasonable and that in any case difference between constructor and Reset was
wrong).

       weak_factory_(this) {
+  Reset();
 }
 
 EventSender::~EventSender() {}
 
 void EventSender::Reset() {
   DCHECK(current_drag_data_.isNull());
   current_drag_data_.reset();
   current_drag_effect_ = blink::WebDragOperationNone;
   current_drag_effects_allowed_ = blink::WebDragOperationNone;
-  if (view_ &&
+  if (view() &&
       current_pointer_state_[kMousePointerId].pressed_button_ !=
           WebMouseEvent::ButtonNone)
-    view_->mouseCaptureLost();
+    view()->mouseCaptureLost();
   current_pointer_state_.clear();
   is_drag_mode_ = true;
   force_layout_on_events_ = true;
 
 #if defined(OS_WIN)
   wm_key_down_ = WM_KEYDOWN;
   wm_key_up_ = WM_KEYUP;
   wm_char_ = WM_CHAR;
   wm_dead_char_ = WM_DEADCHAR;
   wm_sys_key_down_ = WM_SYSKEYDOWN;
@@ skipping 12 matching lines @@
   mouse_event_queue_.clear();
 
   time_offset_ms_ = 0;
   click_count_ = 0;
 
   touch_modifiers_ = 0;
   touch_cancelable_ = true;
   touch_points_.clear();
 }
 
-void EventSender::Install(WebFrame* frame) {
+void EventSender::Install(WebLocalFrame* frame) {
   EventSenderBindings::Install(weak_factory_.GetWeakPtr(), frame);
 }
 
-void EventSender::SetDelegate(WebTestDelegate* delegate) {
-  delegate_ = delegate;
-}
-
-void EventSender::SetWebView(WebView* view) {
-  view_ = view;
-}
-
 void EventSender::SetContextMenuData(const WebContextMenuData& data) {
   last_context_menu_data_.reset(new WebContextMenuData(data));
 }
 
 void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseDown,
                  current_pointer_state_[kMousePointerId].pressed_button_,
                  current_pointer_state_[kMousePointerId].current_buttons_,
                  current_pointer_state_[kMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  current_pointer_state_[kMousePointerId].modifiers_,
                  blink::WebPointerProperties::PointerType::Mouse,
                  0,
                  &event);
   WebPoint client_point(event.x, event.y);
   WebPoint screen_point(event.globalX, event.globalY);
   current_drag_data_ = drag_data;
   current_drag_effects_allowed_ = mask;
-  current_drag_effect_ = view_->dragTargetDragEnter(
-      drag_data,
-      client_point,
-      screen_point,
-      current_drag_effects_allowed_,
+  current_drag_effect_ = view()->dragTargetDragEnter(
+      drag_data, client_point, screen_point, current_drag_effects_allowed_,
       modifiersWithButtons(
           current_pointer_state_[kMousePointerId].modifiers_,
           current_pointer_state_[kMousePointerId].current_buttons_));
 
   // Finish processing events.
   ReplaySavedEvents();
 }
 
 void EventSender::MouseDown(int button_number, int modifiers) {
   PointerDown(button_number, modifiers,
               blink::WebPointerProperties::PointerType::Mouse, kMousePointerId);
 }
 
 void EventSender::MouseUp(int button_number, int modifiers) {
   PointerUp(button_number, modifiers,
             blink::WebPointerProperties::PointerType::Mouse, kMousePointerId);
 }
 
 void EventSender::PointerDown(
     int button_number,
     int modifiers,
     blink::WebPointerProperties::PointerType pointerType,
     int pointerId) {
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
   WebMouseEvent event;
   int click_count = 0;
   current_pointer_state_[pointerId].pressed_button_ = button_type;
   current_pointer_state_[pointerId].current_buttons_ |=
@@ skipping 17 matching lines @@
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::PointerUp(
     int button_number,
     int modifiers,
     blink::WebPointerProperties::PointerType pointerType,
     int pointerId) {
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
   if (pointerType == blink::WebPointerProperties::PointerType::Mouse &&
       is_drag_mode_ && !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_MOUSE_UP;
@@ skipping 206 matching lines @@
     event_down.modifiers |= WebInputEvent::IsKeyPad;
     break;
   }
 
   WebKeyboardEvent event_up;
   event_up = event_down;
   event_up.type = WebInputEvent::KeyUp;
   // EventSender.m forces a layout here, with at least one
   // test (fast/forms/focus-control-to-page.html) relying on this.
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   // In the browser, if a keyboard event corresponds to an editor command,
   // the command will be dispatched to the renderer just before dispatching
   // the keyboard event, and then it will be executed in the
   // RenderView::handleCurrentKeyboardEvent() method.
   // We just simulate the same behavior here.
   std::string edit_command;
   if (GetEditCommand(event_down, &edit_command))
-    delegate_->SetEditCommand(edit_command, "");
+    delegate()->SetEditCommand(edit_command, "");
 
   HandleInputEventOnViewOrPopup(event_down);
 
   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
     WebMouseEvent event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    current_pointer_state_[kMousePointerId].pressed_button_,
                    current_pointer_state_[kMousePointerId].current_buttons_,
                    current_pointer_state_[kMousePointerId].last_pos_,
                    GetCurrentEventTimeSec(),
                    click_count_,
                    0,
                    blink::WebPointerProperties::PointerType::Mouse,
                    0,
                    &event);
     FinishDragAndDrop(event, blink::WebDragOperationNone);
   }
 
-  delegate_->ClearEditCommand();
+  delegate()->ClearEditCommand();
 
   if (generate_char) {
     WebKeyboardEvent event_char = event_up;
     event_char.type = WebInputEvent::Char;
     // keyIdentifier is an empty string, unless the Enter key was pressed.
     // This behavior is not standard (keyIdentifier itself is not even a
     // standard any more), but it matches the actual behavior in Blink.
     if (code != ui::VKEY_RETURN)
       event_char.keyIdentifier[0] = '\0';
     HandleInputEventOnViewOrPopup(event_char);
   }
 
   HandleInputEventOnViewOrPopup(event_up);
 }
 
 void EventSender::EnableDOMUIEventLogging() {}
 
 void EventSender::FireKeyboardEventsToElement() {}
 
 void EventSender::ClearKillRing() {}
 
 std::vector<std::string> EventSender::ContextClick() {
   if (force_layout_on_events_) {
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
   }
 
   UpdateClickCountForButton(WebMouseEvent::ButtonRight);
 
   // Clears last context menu data because we need to know if the context menu
   // be requested after following mouse events.
   last_context_menu_data_.reset();
 
   // Generate right mouse down and up.
   WebMouseEvent event;
@@ skipping 35 matching lines @@
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
                  blink::WebPointerProperties::PointerType::Mouse,
                  0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 #endif
 
   std::vector<std::string> menu_items =
-      MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate_);
+      MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate());
   last_context_menu_data_.reset();
   return menu_items;
 }
 
 void EventSender::TextZoomIn() {
-  view_->setTextZoomFactor(view_->textZoomFactor() * 1.2f);
+  view()->setTextZoomFactor(view()->textZoomFactor() * 1.2f);
 }
 
 void EventSender::TextZoomOut() {
-  view_->setTextZoomFactor(view_->textZoomFactor() / 1.2f);
+  view()->setTextZoomFactor(view()->textZoomFactor() / 1.2f);
 }
 
 void EventSender::ZoomPageIn() {
   const std::vector<WebTestProxyBase*>& window_list =
-      interfaces_->GetWindowList();
+      interfaces()->GetWindowList();
 
   for (size_t i = 0; i < window_list.size(); ++i) {
     window_list.at(i)->web_view()->setZoomLevel(
         window_list.at(i)->web_view()->zoomLevel() + 1);
   }
 }
 
 void EventSender::ZoomPageOut() {
   const std::vector<WebTestProxyBase*>& window_list =
-      interfaces_->GetWindowList();
+      interfaces()->GetWindowList();
 
   for (size_t i = 0; i < window_list.size(); ++i) {
     window_list.at(i)->web_view()->setZoomLevel(
         window_list.at(i)->web_view()->zoomLevel() - 1);
   }
 }
 
 void EventSender::SetPageZoomFactor(double zoom_factor) {
   const std::vector<WebTestProxyBase*>& window_list =
-      interfaces_->GetWindowList();
+      interfaces()->GetWindowList();
 
   for (size_t i = 0; i < window_list.size(); ++i) {
     window_list.at(i)->web_view()->setZoomLevel(std::log(zoom_factor) /
                                                 std::log(1.2));
   }
 }
 
 void EventSender::ClearTouchPoints() {
   touch_points_.clear();
 }
@@ skipping 61 matching lines @@
     return;
 
   WebString filename;
   WebVector<WebDragData::Item> items = current_drag_data_.items();
   for (size_t i = 0; i < items.size(); ++i) {
     if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
       filename = items[i].title;
       break;
     }
   }
-  delegate_->PrintMessage(std::string("Filename being dragged: ") +
-                          filename.utf8().data() + "\n");
+  delegate()->PrintMessage(std::string("Filename being dragged: ") +
+                           filename.utf8().data() + "\n");
 }
 
 void EventSender::GestureFlingCancel() {
   WebGestureEvent event;
   event.type = WebInputEvent::GestureFlingCancel;
   // Generally it won't matter what device we use here, and since it might
   // be cumbersome to expect all callers to specify a device, we'll just
   // choose Touchpad here.
   event.sourceDevice = blink::WebGestureDeviceTouchpad;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::GestureFlingStart(float x,
                                     float y,
                                     float velocity_x,
                                     float velocity_y,
                                     gin::Arguments* args) {
   WebGestureEvent event;
@@ skipping 15 matching lines @@
   event.x = x;
   event.y = y;
   event.globalX = event.x;
   event.globalY = event.y;
 
   event.data.flingStart.velocityX = velocity_x;
   event.data.flingStart.velocityY = velocity_y;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 bool EventSender::IsFlinging() const {
-  return view_->isFlinging();
+  return view()->isFlinging();
 }
 
 void EventSender::GestureScrollFirstPoint(int x, int y) {
   current_gesture_location_ = WebPoint(x, y);
 }
 
 void EventSender::TouchStart() {
   SendCurrentTouchEvent(WebInputEvent::TouchStart, false);
 }
 
@@ skipping 38 matching lines @@
     isolate->ThrowException(v8::Exception::Error(
         gin::StringToV8(isolate,
                         "Nested beginDragWithFiles() not supported.")));
     return;
   }
   current_drag_data_.initialize();
   WebVector<WebString> absolute_filenames(files.size());
   for (size_t i = 0; i < files.size(); ++i) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeFilename;
-    item.filenameData = delegate_->GetAbsoluteWebStringFromUTF8Path(files[i]);
+    item.filenameData = delegate()->GetAbsoluteWebStringFromUTF8Path(files[i]);
     current_drag_data_.addItem(item);
     absolute_filenames[i] = item.filenameData;
   }
   current_drag_data_.setFilesystemId(
-      delegate_->RegisterIsolatedFileSystem(absolute_filenames));
+      delegate()->RegisterIsolatedFileSystem(absolute_filenames));
   current_drag_effects_allowed_ = blink::WebDragOperationCopy;
 
   // Provide a drag source.
-  view_->dragTargetDragEnter(current_drag_data_,
-                             current_pointer_state_[kMousePointerId].last_pos_,
-                             current_pointer_state_[kMousePointerId].last_pos_,
-                             current_drag_effects_allowed_,
-                             0);
+  view()->dragTargetDragEnter(current_drag_data_,
+                              current_pointer_state_[kMousePointerId].last_pos_,
+                              current_pointer_state_[kMousePointerId].last_pos_,
+                              current_drag_effects_allowed_, 0);
   // |is_drag_mode_| saves events and then replays them later. We don't
   // need/want that.
   is_drag_mode_ = false;
 
   // Make the rest of eventSender think a drag is in progress.
   current_pointer_state_[kMousePointerId].pressed_button_ =
       WebMouseEvent::ButtonLeft;
   current_pointer_state_[kMousePointerId].current_buttons_ |=
       GetWebMouseEventModifierForButton(
           current_pointer_state_[kMousePointerId].pressed_button_);
@@ skipping 85 matching lines @@
   InitMouseWheelEvent(args, scroll_type, &wheel_event, &send_gestures);
   if (HandleInputEventOnViewOrPopup(wheel_event) ==
           WebInputEventResult::NotHandled &&
       send_gestures) {
     SendGesturesForMouseWheelEvent(wheel_event);
   }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   double x;
   double y;
   blink::WebPointerProperties::PointerType pointerType =
       blink::WebPointerProperties::PointerType::Mouse;
   int pointerId = 0;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
     args->ThrowError();
     return;
   }
@@ skipping 34 matching lines @@
         pointerId,
         &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == blink::WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseMove(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseLeave,
                  WebMouseEvent::ButtonNone,
                  0,
                  current_pointer_state_[kMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
                  blink::WebPointerProperties::PointerType::Mouse,
                  0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
-  delegate_->PostTask(new WebCallbackTask(
+  delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseDown, weak_factory_.GetWeakPtr(),
                  button_number, modifiers)));
-  delegate_->PostTask(new WebCallbackTask(
+  delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseUp, weak_factory_.GetWeakPtr(),
                  button_number, modifiers)));
 }
 
 void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
                                               int modifiers,
                                               KeyLocationCode location) {
-  delegate_->PostTask(new WebCallbackTask(
+  delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::KeyDown, weak_factory_.GetWeakPtr(), code_str,
                  modifiers, location)));
 }
 
 double EventSender::GetCurrentEventTimeSec() {
   return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF() +
          time_offset_ms_ / 1000.0;
 }
 
 void EventSender::DoLeapForward(int milliseconds) {
   time_offset_ms_ += milliseconds;
 }
 
 void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
                                         bool movedBeyondSlopRegion) {
   DCHECK_GT(static_cast<unsigned>(WebTouchEvent::touchesLengthCap),
             touch_points_.size());
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   WebTouchEvent touch_event;
   touch_event.type = type;
   touch_event.modifiers = touch_modifiers_;
   touch_event.dispatchType = touch_cancelable_
                                  ? WebInputEvent::Blocking
                                  : WebInputEvent::EventNonBlocking;
   touch_event.timeStampSeconds = GetCurrentEventTimeSec();
   touch_event.movedBeyondSlopRegion = movedBeyondSlopRegion;
   touch_event.touchesLength = touch_points_.size();
@@ skipping 254 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 
   event.globalX = event.x;
   event.globalY = event.y;
   event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   WebInputEventResult result = HandleInputEventOnViewOrPopup(event);
 
   // Long press might start a drag drop session. Complete it if so.
   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
     WebMouseEvent mouse_event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    current_pointer_state_[kMousePointerId].pressed_button_,
                    current_pointer_state_[kMousePointerId].current_buttons_,
                    WebPoint(x, y), GetCurrentEventTimeSec(),
@@ skipping 24 matching lines @@
 }
 
 void EventSender::InitMouseWheelEvent(gin::Arguments* args,
                                       MouseScrollType scroll_type,
                                       WebMouseWheelEvent* event,
                                       bool* send_gestures) {
   // Force a layout here just to make sure every position has been
   // determined before we send events (as well as all the other methods
   // that send an event do).
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   double horizontal;
   if (!args->GetNext(&horizontal)) {
     args->ThrowError();
     return;
   }
   double vertical;
   if (!args->GetNext(&vertical)) {
     args->ThrowError();
     return;
@@ skipping 98 matching lines @@
 }
 
 void EventSender::FinishDragAndDrop(const WebMouseEvent& e,
                                      blink::WebDragOperation drag_effect) {
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
   current_drag_effect_ = drag_effect;
   if (current_drag_effect_) {
     // Specifically pass any keyboard modifiers to the drop method. This allows
     // tests to control the drop type (i.e. copy or move).
-    view_->dragTargetDrop(client_point, screen_point, e.modifiers);
+    view()->dragTargetDrop(client_point, screen_point, e.modifiers);
   } else {
-    view_->dragTargetDragLeave();
+    view()->dragTargetDragLeave();
   }
-  view_->dragSourceEndedAt(client_point, screen_point, current_drag_effect_);
-  view_->dragSourceSystemDragEnded();
+  view()->dragSourceEndedAt(client_point, screen_point, current_drag_effect_);
+  view()->dragSourceSystemDragEnded();
 
   current_drag_data_.reset();
 }
 
 void EventSender::DoDragAfterMouseUp(const WebMouseEvent& e) {
   last_click_time_sec_ = e.timeStampSeconds;
   last_click_pos_ = current_pointer_state_[kMousePointerId].last_pos_;
 
   // If we're in a drag operation, complete it.
   if (current_drag_data_.isNull())
     return;
 
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
-  blink::WebDragOperation drag_effect = view_->dragTargetDragOver(
-      client_point,
-      screen_point,
-      current_drag_effects_allowed_,
-      e.modifiers);
+  blink::WebDragOperation drag_effect = view()->dragTargetDragOver(
+      client_point, screen_point, current_drag_effects_allowed_, e.modifiers);
 
   // Bail if dragover caused cancellation.
   if (current_drag_data_.isNull())
     return;
 
   FinishDragAndDrop(e, drag_effect);
 }
 
 void EventSender::DoDragAfterMouseMove(const WebMouseEvent& e) {
   if (current_pointer_state_[kMousePointerId].pressed_button_ ==
           WebMouseEvent::ButtonNone ||
       current_drag_data_.isNull()) {
     return;
   }
 
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
-  current_drag_effect_ = view_->dragTargetDragOver(
+  current_drag_effect_ = view()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_, e.modifiers);
 }
 
 void EventSender::ReplaySavedEvents() {
   replaying_saved_events_ = true;
   while (!mouse_event_queue_.empty()) {
     SavedEvent e = mouse_event_queue_.front();
     mouse_event_queue_.pop_front();
 
     switch (e.type) {
@@ skipping 45 matching lines @@
     }
   }
 
   replaying_saved_events_ = false;
 }
 
 WebInputEventResult EventSender::HandleInputEventOnViewOrPopup(
     const WebInputEvent& event) {
   last_event_timestamp_ = event.timeStampSeconds;
 
-  if (WebPagePopup* popup = view_->pagePopup()) {
+  if (WebPagePopup* popup = view()->pagePopup()) {
     if (!WebInputEvent::isKeyboardEventType(event.type))
       return popup->handleInputEvent(event);
   }
-  return view_->handleInputEvent(event);
+  return view()->handleInputEvent(event);
 }
 
 void EventSender::SendGesturesForMouseWheelEvent(
     const WebMouseWheelEvent wheel_event) {
   WebGestureEvent begin_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollBegin,
                                  GetCurrentEventTimeSec(), wheel_event,
                                  &begin_event);
   begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX;
   begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY;
   if (wheel_event.scrollByPage) {
     begin_event.data.scrollBegin.deltaHintUnits = blink::WebGestureEvent::Page;
     if (begin_event.data.scrollBegin.deltaXHint) {
       begin_event.data.scrollBegin.deltaXHint =
           begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
     }
     if (begin_event.data.scrollBegin.deltaYHint) {
       begin_event.data.scrollBegin.deltaYHint =
           begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1;
     }
   } else {
     begin_event.data.scrollBegin.deltaHintUnits =
         wheel_event.hasPreciseScrollingDeltas
             ? blink::WebGestureEvent::PrecisePixels
             : blink::WebGestureEvent::Pixels;
   }
 
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(begin_event);
 
   WebGestureEvent update_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollUpdate,
                                  GetCurrentEventTimeSec(), wheel_event,
                                  &update_event);
   update_event.data.scrollUpdate.deltaX =
       begin_event.data.scrollBegin.deltaXHint;
   update_event.data.scrollUpdate.deltaY =
       begin_event.data.scrollBegin.deltaYHint;
   update_event.data.scrollUpdate.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(update_event);
 
   WebGestureEvent end_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollEnd,
                                  GetCurrentEventTimeSec(), wheel_event,
                                  &end_event);
   end_event.data.scrollEnd.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
-    view_->updateAllLifecyclePhases();
+    view()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(end_event);
 }
 
+TestInterfaces* EventSender::interfaces() {
+  return web_test_proxy_base_->test_interfaces();
+}
+
+WebTestDelegate* EventSender::delegate() {
+  return web_test_proxy_base_->delegate();
+}
+
+const blink::WebView* EventSender::view() const {
+  return web_test_proxy_base_->web_view();
+}
+
+blink::WebView* EventSender::view() {
+  return web_test_proxy_base_->web_view();
+}
+
 }  // namespace test_runner