Update {virtual,override} to follow C++11 style in content.

content/renderer/input/input_handler_proxy_unittest.cc

 // Copyright 2013 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/input/input_handler_proxy.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "content/common/input/did_overscroll_params.h"
@@ skipping 57 matching lines @@
                      source_device,
                      velocity,
                      point,
                      global_point,
                      modifiers);
 }
 
 class MockInputHandler : public cc::InputHandler {
  public:
   MockInputHandler() {}
-  virtual ~MockInputHandler() {}
+  ~MockInputHandler() override {}
 
   MOCK_METHOD0(PinchGestureBegin, void());
   MOCK_METHOD2(PinchGestureUpdate,
                void(float magnify_delta, const gfx::Point& anchor));
   MOCK_METHOD0(PinchGestureEnd, void());
 
   MOCK_METHOD0(SetNeedsAnimate, void());
 
   MOCK_METHOD2(ScrollBegin,
                ScrollStatus(const gfx::Point& viewport_point,
                             cc::InputHandler::ScrollInputType type));
   MOCK_METHOD2(ScrollAnimated,
                ScrollStatus(const gfx::Point& viewport_point,
                             const gfx::Vector2dF& scroll_delta));
   MOCK_METHOD2(ScrollBy,
                cc::InputHandlerScrollResult(
                    const gfx::Point& viewport_point,
                    const gfx::Vector2dF& scroll_delta));
   MOCK_METHOD2(ScrollVerticallyByPage,
                bool(const gfx::Point& viewport_point,
                     cc::ScrollDirection direction));
   MOCK_METHOD0(ScrollEnd, void());
   MOCK_METHOD0(FlingScrollBegin, cc::InputHandler::ScrollStatus());
 
-  virtual scoped_ptr<cc::SwapPromiseMonitor>
-    CreateLatencyInfoSwapPromiseMonitor(ui::LatencyInfo* latency) override {
-      return scoped_ptr<cc::SwapPromiseMonitor>();
+  scoped_ptr<cc::SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
+      ui::LatencyInfo* latency) override {
+    return scoped_ptr<cc::SwapPromiseMonitor>();
   }
 
   cc::ScrollElasticityHelper* CreateScrollElasticityHelper() override {
     return NULL;
   }
 
-  virtual void BindToClient(cc::InputHandlerClient* client) override {}
+  void BindToClient(cc::InputHandlerClient* client) override {}
 
-  virtual void MouseMoveAt(const gfx::Point& mouse_position) override {}
+  void MouseMoveAt(const gfx::Point& mouse_position) override {}
 
   MOCK_METHOD2(IsCurrentlyScrollingLayerAt,
                bool(const gfx::Point& point,
                     cc::InputHandler::ScrollInputType type));
 
   MOCK_METHOD1(HaveWheelEventHandlersAt, bool(const gfx::Point& point));
   MOCK_METHOD1(DoTouchEventsBlockScrollAt, bool(const gfx::Point& point));
 
-  virtual void SetRootLayerScrollOffsetDelegate(
+  void SetRootLayerScrollOffsetDelegate(
       cc::LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate)
       override {}
 
-  virtual void OnRootLayerDelegatedScrollOffsetChanged() override {}
+  void OnRootLayerDelegatedScrollOffsetChanged() override {}
 
   DISALLOW_COPY_AND_ASSIGN(MockInputHandler);
 };
 
 // A simple WebGestureCurve implementation that flings at a constant velocity
 // indefinitely.
 class FakeWebGestureCurve : public blink::WebGestureCurve {
  public:
   FakeWebGestureCurve(const blink::WebFloatSize& velocity,
                       const blink::WebFloatSize& cumulative_scroll)
@@ skipping 18 matching lines @@
   blink::WebFloatSize velocity_;
   blink::WebFloatSize cumulative_scroll_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWebGestureCurve);
 };
 
 class MockInputHandlerProxyClient
     : public content::InputHandlerProxyClient {
  public:
   MockInputHandlerProxyClient() {}
-  virtual ~MockInputHandlerProxyClient() {}
+  ~MockInputHandlerProxyClient() override {}
 
-  virtual void WillShutdown() override {}
+  void WillShutdown() override {}
 
   MOCK_METHOD1(TransferActiveWheelFlingAnimation,
                void(const WebActiveWheelFlingParameters&));
 
-  virtual blink::WebGestureCurve* CreateFlingAnimationCurve(
+  blink::WebGestureCurve* CreateFlingAnimationCurve(
       WebGestureDevice deviceSource,
       const WebFloatPoint& velocity,
       const WebSize& cumulative_scroll) override {
     return new FakeWebGestureCurve(
         blink::WebFloatSize(velocity.x, velocity.y),
         blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height));
   }
 
   MOCK_METHOD1(DidOverscroll, void(const DidOverscrollParams&));
-  virtual void DidStopFlinging() override {}
-  virtual void DidReceiveInputEvent(const blink::WebInputEvent&) override {}
-  virtual void DidAnimateForInput() override {}
+  void DidStopFlinging() override {}
+  void DidReceiveInputEvent(const blink::WebInputEvent&) override {}
+  void DidAnimateForInput() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient);
 };
 
 class MockInputHandlerProxyClientWithDidReceiveInputEvent
     : public MockInputHandlerProxyClient {
  public:
   MockInputHandlerProxyClientWithDidReceiveInputEvent() {}
-  virtual ~MockInputHandlerProxyClientWithDidReceiveInputEvent() {}
+  ~MockInputHandlerProxyClientWithDidReceiveInputEvent() override {}
 
   MOCK_METHOD1(DidReceiveInputEvent, void(const blink::WebInputEvent&));
   MOCK_METHOD0(DidAnimateForInput, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClientWithDidReceiveInputEvent);
 };
 
 WebTouchPoint CreateWebTouchPoint(WebTouchPoint::State state, float x,
                                   float y) {
@@ skipping 1925 matching lines @@
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_client, DidAnimateForInput());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 }
 
 } // namespace
 } // namespace content