replace OVERRIDE and FINAL with override and final in chrome/browser/chromeos/

chrome/browser/chromeos/file_system_provider/request_manager_unittest.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 "chrome/browser/chromeos/file_system_provider/request_manager.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 17 matching lines @@
 // Fake implementation for the notification manager. Simulates user action on
 // a notification.
 class FakeNotificationManager : public NotificationManagerInterface {
  public:
   FakeNotificationManager() {}
   virtual ~FakeNotificationManager() {}
 
   // NotificationManagerInterface overrides:
   virtual void ShowUnresponsiveNotification(
       int id,
-      const NotificationCallback& callback) OVERRIDE {
+      const NotificationCallback& callback) override {
     callbacks_[id] = callback;
   }
 
-  virtual void HideUnresponsiveNotification(int id) OVERRIDE {
+  virtual void HideUnresponsiveNotification(int id) override {
     callbacks_.erase(id);
   }
 
   // Aborts all of the virtually shown notifications.
   void Abort() { OnNotificationResult(ABORT); }
 
   // Discards all of the virtually shown notifications.
   void Continue() { OnNotificationResult(CONTINUE); }
 
   // Returns number of currently shown notifications.
@@ skipping 109 matching lines @@
 // Fake handler, which forwards callbacks to the logger. The handler is owned
 // by a request manager, however the logger is owned by tests.
 class FakeHandler : public RequestManager::HandlerInterface {
  public:
   // The handler can outlive the passed logger, so using a weak pointer. The
   // |execute_reply| value will be returned for the Execute() call.
   FakeHandler(base::WeakPtr<EventLogger> logger, bool execute_reply)
       : logger_(logger), execute_reply_(execute_reply) {}
 
   // RequestManager::Handler overrides.
-  virtual bool Execute(int request_id) OVERRIDE {
+  virtual bool Execute(int request_id) override {
     if (logger_.get())
       logger_->OnExecute(request_id);
 
     return execute_reply_;
   }
 
   // RequestManager::Handler overrides.
   virtual void OnSuccess(int request_id,
                          scoped_ptr<RequestValue> result,
-                         bool has_more) OVERRIDE {
+                         bool has_more) override {
     if (logger_.get())
       logger_->OnSuccess(request_id, result.Pass(), has_more);
   }
 
   // RequestManager::Handler overrides.
   virtual void OnError(int request_id,
                        scoped_ptr<RequestValue> result,
-                       base::File::Error error) OVERRIDE {
+                       base::File::Error error) override {
     if (logger_.get())
       logger_->OnError(request_id, result.Pass(), error);
   }
 
   virtual ~FakeHandler() {}
 
  private:
   base::WeakPtr<EventLogger> logger_;
   bool execute_reply_;
   DISALLOW_COPY_AND_ASSIGN(FakeHandler);
@@ skipping 45 matching lines @@
     base::File::Error error() const { return error_; }
 
    private:
     base::File::Error error_;
   };
 
   RequestObserver() {}
   virtual ~RequestObserver() {}
 
   // RequestManager::Observer overrides.
-  virtual void OnRequestCreated(int request_id, RequestType type) OVERRIDE {
+  virtual void OnRequestCreated(int request_id, RequestType type) override {
     created_.push_back(CreatedEvent(request_id, type));
   }
 
   // RequestManager::Observer overrides.
-  virtual void OnRequestDestroyed(int request_id) OVERRIDE {
+  virtual void OnRequestDestroyed(int request_id) override {
     destroyed_.push_back(Event(request_id));
   }
 
   // RequestManager::Observer overrides.
-  virtual void OnRequestExecuted(int request_id) OVERRIDE {
+  virtual void OnRequestExecuted(int request_id) override {
     executed_.push_back(Event(request_id));
   }
 
   // RequestManager::Observer overrides.
   virtual void OnRequestFulfilled(int request_id,
                                   const RequestValue& result,
-                                  bool has_more) OVERRIDE {
+                                  bool has_more) override {
     fulfilled_.push_back(FulfilledEvent(request_id, has_more));
   }
 
   // RequestManager::Observer overrides.
   virtual void OnRequestRejected(int request_id,
                                  const RequestValue& result,
-                                 base::File::Error error) OVERRIDE {
+                                 base::File::Error error) override {
     rejected_.push_back(RejectedEvent(request_id, error));
   }
 
   // RequestManager::Observer overrides.
-  virtual void OnRequestTimeouted(int request_id) OVERRIDE {
+  virtual void OnRequestTimeouted(int request_id) override {
     timeouted_.push_back(Event(request_id));
   }
 
   const std::vector<CreatedEvent>& created() const { return created_; }
   const std::vector<Event>& destroyed() const { return destroyed_; }
   const std::vector<Event>& executed() const { return executed_; }
   const std::vector<FulfilledEvent>& fulfilled() const { return fulfilled_; }
   const std::vector<RejectedEvent>& rejected() const { return rejected_; }
   const std::vector<Event>& timeouted() const { return timeouted_; }
 
  private:
   std::vector<CreatedEvent> created_;
   std::vector<Event> destroyed_;
   std::vector<Event> executed_;
   std::vector<FulfilledEvent> fulfilled_;
   std::vector<RejectedEvent> rejected_;
   std::vector<Event> timeouted_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestObserver);
 };
 
 }  // namespace
 
 class FileSystemProviderRequestManagerTest : public testing::Test {
  protected:
   FileSystemProviderRequestManagerTest() {}
   virtual ~FileSystemProviderRequestManagerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     notification_manager_.reset(new FakeNotificationManager);
     request_manager_.reset(new RequestManager(notification_manager_.get()));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<FakeNotificationManager> notification_manager_;
   scoped_ptr<RequestManager> request_manager_;
 };
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateFailure) {
@@ skipping 474 matching lines @@
 
   // Wait until the request is timeouted again.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, notification_manager_->size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos