Replace FINAL and OVERRIDE with their C++11 counterparts in content/renderer

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/base/swap_promise_monitor.h"
 #include "content/common/input/did_overscroll_params.h"
@@ skipping 81 matching lines @@
   MOCK_METHOD2(ScrollBy,
                bool(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 {
+    CreateLatencyInfoSwapPromiseMonitor(ui::LatencyInfo* latency) override {
       return scoped_ptr<cc::SwapPromiseMonitor>();
   }
 
-  virtual void BindToClient(cc::InputHandlerClient* client) OVERRIDE {}
+  virtual void BindToClient(cc::InputHandlerClient* client) override {}
 
-  virtual void MouseMoveAt(const gfx::Point& mouse_position) OVERRIDE {}
+  virtual void MouseMoveAt(const gfx::Point& mouse_position) override {}
 
   MOCK_METHOD2(IsCurrentlyScrollingLayerAt,
                bool(const gfx::Point& point,
                     cc::InputHandler::ScrollInputType type));
 
   MOCK_METHOD1(HaveTouchEventHandlersAt, bool(const gfx::Point& point));
 
   virtual void SetRootLayerScrollOffsetDelegate(
       cc::LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate)
-      OVERRIDE {}
+      override {}
 
-  virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE {}
+  virtual 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 20 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FakeWebGestureCurve);
 };
 
 class MockInputHandlerProxyClient
     : public content::InputHandlerProxyClient {
  public:
   MockInputHandlerProxyClient() {}
   virtual ~MockInputHandlerProxyClient() {}
 
-  virtual void WillShutdown() OVERRIDE {}
+  virtual void WillShutdown() override {}
 
   MOCK_METHOD1(TransferActiveWheelFlingAnimation,
                void(const WebActiveWheelFlingParameters&));
 
   virtual blink::WebGestureCurve* CreateFlingAnimationCurve(
       WebGestureDevice deviceSource,
       const WebFloatPoint& velocity,
-      const WebSize& cumulative_scroll) OVERRIDE {
+      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() OVERRIDE {}
+  virtual void DidStopFlinging() override {}
+  virtual void DidReceiveInputEvent() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient);
 };
 
 class MockInputHandlerProxyClientWithDidReceiveInputEvent
     : public MockInputHandlerProxyClient {
  public:
   MockInputHandlerProxyClientWithDidReceiveInputEvent() {}
   virtual ~MockInputHandlerProxyClientWithDidReceiveInputEvent() {}
@@ skipping 1809 matching lines @@
   wheel.scrollByPage = true;
 
   EXPECT_CALL(mock_client, DidReceiveInputEvent());
 
   input_handler_->HandleInputEvent(wheel);
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 }
 
 } // namespace
 } // namespace content