Replacing the OVERRIDE with override and FINAL with final in content/browser/renderer_host

content/browser/renderer_host/render_widget_host_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/timer/timer.h"
@@ skipping 52 matching lines @@
         sent_wheel_event_(false),
         sent_keyboard_event_(false),
         sent_gesture_event_(false),
         send_touch_event_not_cancelled_(false),
         message_received_(false),
         client_(client) {
   }
   virtual ~MockInputRouter() {}
 
   // InputRouter
-  virtual void Flush() OVERRIDE {
+  virtual void Flush() override {
     flush_called_ = true;
   }
-  virtual bool SendInput(scoped_ptr<IPC::Message> message) OVERRIDE {
+  virtual bool SendInput(scoped_ptr<IPC::Message> message) override {
     send_event_called_ = true;
     return true;
   }
   virtual void SendMouseEvent(
-      const MouseEventWithLatencyInfo& mouse_event) OVERRIDE {
+      const MouseEventWithLatencyInfo& mouse_event) override {
     sent_mouse_event_ = true;
   }
   virtual void SendWheelEvent(
-      const MouseWheelEventWithLatencyInfo& wheel_event) OVERRIDE {
+      const MouseWheelEventWithLatencyInfo& wheel_event) override {
     sent_wheel_event_ = true;
   }
   virtual void SendKeyboardEvent(
       const NativeWebKeyboardEvent& key_event,
       const ui::LatencyInfo& latency_info,
-      bool is_shortcut) OVERRIDE {
+      bool is_shortcut) override {
     sent_keyboard_event_ = true;
   }
   virtual void SendGestureEvent(
-      const GestureEventWithLatencyInfo& gesture_event) OVERRIDE {
+      const GestureEventWithLatencyInfo& gesture_event) override {
     sent_gesture_event_ = true;
   }
   virtual void SendTouchEvent(
-      const TouchEventWithLatencyInfo& touch_event) OVERRIDE {
+      const TouchEventWithLatencyInfo& touch_event) override {
     send_touch_event_not_cancelled_ =
         client_->FilterInputEvent(touch_event.event, touch_event.latency) ==
         INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
   }
-  virtual const NativeWebKeyboardEvent* GetLastKeyboardEvent() const OVERRIDE {
+  virtual const NativeWebKeyboardEvent* GetLastKeyboardEvent() const override {
     NOTREACHED();
     return NULL;
   }
-  virtual bool ShouldForwardTouchEvent() const OVERRIDE { return true; }
-  virtual void OnViewUpdated(int view_flags) OVERRIDE {}
-  virtual bool HasPendingEvents() const OVERRIDE { return false; }
+  virtual bool ShouldForwardTouchEvent() const override { return true; }
+  virtual void OnViewUpdated(int view_flags) override {}
+  virtual bool HasPendingEvents() const override { return false; }
 
   // IPC::Listener
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+  virtual bool OnMessageReceived(const IPC::Message& message) override {
     message_received_ = true;
     return false;
   }
 
   bool flush_called_;
   bool send_event_called_;
   bool sent_mouse_event_;
   bool sent_wheel_event_;
   bool sent_keyboard_event_;
   bool sent_gesture_event_;
@@ skipping 22 matching lines @@
   // Allow poking at a few private members.
   using RenderWidgetHostImpl::OnUpdateRect;
   using RenderWidgetHostImpl::RendererExited;
   using RenderWidgetHostImpl::last_requested_size_;
   using RenderWidgetHostImpl::is_hidden_;
   using RenderWidgetHostImpl::resize_ack_pending_;
   using RenderWidgetHostImpl::input_router_;
 
   virtual void OnTouchEventAck(
       const TouchEventWithLatencyInfo& event,
-      InputEventAckState ack_result) OVERRIDE {
+      InputEventAckState ack_result) override {
     // Sniff touch acks.
     acked_touch_event_type_ = event.event.type;
     RenderWidgetHostImpl::OnTouchEventAck(event, ack_result);
   }
 
   bool unresponsive_timer_fired() const {
     return unresponsive_timer_fired_;
   }
 
   void set_hung_renderer_delay_ms(int delay_ms) {
@@ skipping 11 matching lines @@
 
   void SetupForInputRouterTest() {
     input_router_.reset(new MockInputRouter(this));
   }
 
   MockInputRouter* mock_input_router() {
     return static_cast<MockInputRouter*>(input_router_.get());
   }
 
  protected:
-  virtual void NotifyRendererUnresponsive() OVERRIDE {
+  virtual void NotifyRendererUnresponsive() override {
     unresponsive_timer_fired_ = true;
   }
 
   bool unresponsive_timer_fired_;
   WebInputEvent::Type acked_touch_event_type_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderWidgetHost);
 };
 
 namespace  {
 
 // RenderWidgetHostProcess -----------------------------------------------------
 
 class RenderWidgetHostProcess : public MockRenderProcessHost {
  public:
   explicit RenderWidgetHostProcess(BrowserContext* browser_context)
       : MockRenderProcessHost(browser_context),
         update_msg_reply_flags_(0) {
   }
   virtual ~RenderWidgetHostProcess() {
   }
 
   void set_update_msg_reply_flags(int flags) {
     update_msg_reply_flags_ = flags;
   }
 
   // Fills the given update parameters with resonable default values.
   void InitUpdateRectParams(ViewHostMsg_UpdateRect_Params* params);
 
-  virtual bool HasConnection() const OVERRIDE { return true; }
+  virtual bool HasConnection() const override { return true; }
 
  protected:
   // Indicates the flags that should be sent with a repaint request. This
   // only has an effect when update_msg_should_reply_ is true.
   int update_msg_reply_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostProcess);
 };
 
 void RenderWidgetHostProcess::InitUpdateRectParams(
@@ skipping 42 matching lines @@
 
   void SetMockPhysicalBackingSize(const gfx::Size& mock_physical_backing_size) {
     use_fake_physical_backing_size_ = true;
     mock_physical_backing_size_ = mock_physical_backing_size;
   }
   void ClearMockPhysicalBackingSize() {
     use_fake_physical_backing_size_ = false;
   }
 
   // RenderWidgetHostView override.
-  virtual gfx::Rect GetViewBounds() const OVERRIDE {
+  virtual gfx::Rect GetViewBounds() const override {
     return bounds_;
   }
   virtual void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch,
-                                      InputEventAckState ack_result) OVERRIDE {
+                                      InputEventAckState ack_result) override {
     acked_event_ = touch.event;
     ++acked_event_count_;
   }
   virtual void WheelEventAck(const WebMouseWheelEvent& event,
-                             InputEventAckState ack_result) OVERRIDE {
+                             InputEventAckState ack_result) override {
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       return;
     unhandled_wheel_event_count_++;
     unhandled_wheel_event_ = event;
   }
   virtual void GestureEventAck(const WebGestureEvent& event,
-                               InputEventAckState ack_result) OVERRIDE {
+                               InputEventAckState ack_result) override {
     gesture_event_type_ = event.type;
     ack_result_ = ack_result;
   }
-  virtual gfx::Size GetPhysicalBackingSize() const OVERRIDE {
+  virtual gfx::Size GetPhysicalBackingSize() const override {
     if (use_fake_physical_backing_size_)
       return mock_physical_backing_size_;
     return TestRenderWidgetHostView::GetPhysicalBackingSize();
   }
 #if defined(USE_AURA)
   virtual ~TestView() {
     // Simulate the mouse exit event dispatched when an aura window is
     // destroyed. (MakeWebMouseEventFromAuraEvent translates ET_MOUSE_EXITED
     // into WebInputEvent::MouseMove.)
     rwh_->input_router()->SendMouseEvent(
@@ skipping 57 matching lines @@
   void set_handle_wheel_event(bool handle) {
     handle_wheel_event_ = handle;
   }
 
   bool handle_wheel_event_called() {
     return handle_wheel_event_called_;
   }
 
  protected:
   virtual bool PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
-                                      bool* is_keyboard_shortcut) OVERRIDE {
+                                      bool* is_keyboard_shortcut) override {
     prehandle_keyboard_event_type_ = event.type;
     prehandle_keyboard_event_called_ = true;
     return prehandle_keyboard_event_;
   }
 
   virtual void HandleKeyboardEvent(
-      const NativeWebKeyboardEvent& event) OVERRIDE {
+      const NativeWebKeyboardEvent& event) override {
     unhandled_keyboard_event_type_ = event.type;
     unhandled_keyboard_event_called_ = true;
   }
 
   virtual bool HandleWheelEvent(
-      const blink::WebMouseWheelEvent& event) OVERRIDE {
+      const blink::WebMouseWheelEvent& event) override {
     handle_wheel_event_called_ = true;
     return handle_wheel_event_;
   }
 
  private:
   bool prehandle_keyboard_event_;
   bool prehandle_keyboard_event_called_;
   WebInputEvent::Type prehandle_keyboard_event_type_;
 
   bool unhandled_keyboard_event_called_;
@@ skipping 1097 matching lines @@
 
   ASSERT_TRUE(host_->is_hidden());
   host_->RendererExited(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   ASSERT_FALSE(host_->is_hidden());
 
   // Make sure the input router is in a fresh state.
   ASSERT_FALSE(host_->input_router()->HasPendingEvents());
 }
 
 }  // namespace content