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

content/browser/appcache/appcache_update_job_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/browser/appcache/appcache_group.h"
@@ skipping 179 matching lines @@
       (*body) = "";
     }
   }
 };
 
 class MockHttpServerJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return MockHttpServer::JobFactory(request, network_delegate);
   }
 };
 
 inline bool operator==(const AppCacheNamespace& lhs,
     const AppCacheNamespace& rhs) {
   return lhs.type == rhs.type &&
          lhs.namespace_url == rhs.namespace_url &&
          lhs.target_url == rhs.target_url;
 }
 
 }  // namespace
 
 class MockFrontend : public AppCacheFrontend {
  public:
   MockFrontend()
       : ignore_progress_events_(false), verify_progress_events_(false),
         last_progress_total_(-1), last_progress_complete_(-1),
         start_update_trigger_(APPCACHE_CHECKING_EVENT), update_(NULL) {
   }
 
   virtual void OnCacheSelected(
-      int host_id, const AppCacheInfo& info) OVERRIDE {
+      int host_id, const AppCacheInfo& info) override {
   }
 
   virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                               AppCacheStatus status) OVERRIDE {
+                               AppCacheStatus status) override {
   }
 
   virtual void OnEventRaised(const std::vector<int>& host_ids,
-                             AppCacheEventID event_id) OVERRIDE {
+                             AppCacheEventID event_id) override {
     raised_events_.push_back(RaisedEvent(host_ids, event_id));
 
     // Trigger additional updates if requested.
     if (event_id == start_update_trigger_ && update_) {
       for (std::vector<AppCacheHost*>::iterator it = update_hosts_.begin();
            it != update_hosts_.end(); ++it) {
         AppCacheHost* host = *it;
         update_->StartUpdate(host,
             (host ? host->pending_master_entry_url() : GURL()));
       }
       update_hosts_.clear();  // only trigger once
     }
   }
 
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
                                   const AppCacheErrorDetails& details)
-      OVERRIDE {
+      override {
     error_message_ = details.message;
     OnEventRaised(host_ids, APPCACHE_ERROR_EVENT);
   }
 
   virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                      const GURL& url,
                                      int num_total,
-                                     int num_complete) OVERRIDE {
+                                     int num_complete) override {
     if (!ignore_progress_events_)
       OnEventRaised(host_ids, APPCACHE_PROGRESS_EVENT);
 
     if (verify_progress_events_) {
       EXPECT_GE(num_total, num_complete);
       EXPECT_GE(num_complete, 0);
 
       if (last_progress_total_ == -1) {
         // Should start at zero.
         EXPECT_EQ(0, num_complete);
       } else {
         // Total should be stable and complete should bump up by one at a time.
         EXPECT_EQ(last_progress_total_, num_total);
         EXPECT_EQ(last_progress_complete_ + 1, num_complete);
       }
 
       // Url should be valid for all except the 'final' event.
       if (num_total == num_complete)
         EXPECT_TRUE(url.is_empty());
       else
         EXPECT_TRUE(url.is_valid());
 
       last_progress_total_ = num_total;
       last_progress_complete_ = num_complete;
     }
   }
 
   virtual void OnLogMessage(int host_id,
                             AppCacheLogLevel log_level,
-                            const std::string& message) OVERRIDE {
+                            const std::string& message) override {
   }
 
   virtual void OnContentBlocked(int host_id,
-                                const GURL& manifest_url) OVERRIDE {
+                                const GURL& manifest_url) override {
   }
 
   void AddExpectedEvent(const std::vector<int>& host_ids,
       AppCacheEventID event_id) {
     DCHECK(!ignore_progress_events_ || event_id != APPCACHE_PROGRESS_EVENT);
     expected_events_.push_back(RaisedEvent(host_ids, event_id));
   }
 
   void SetIgnoreProgressEvents(bool ignore) {
     // Some tests involve joining new hosts to an already running update job
@@ skipping 39 matching lines @@
   AppCacheEventID start_update_trigger_;
   AppCacheUpdateJob* update_;
   std::vector<AppCacheHost*> update_hosts_;
 };
 
 // Helper factories to simulate redirected URL responses for tests.
 class RedirectFactory : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return new net::URLRequestTestJob(
         request,
         network_delegate,
         net::URLRequestTestJob::test_redirect_headers(),
         net::URLRequestTestJob::test_data_1(),
         true);
   }
 };
 
 // Helper class to simulate a URL that returns retry or success.
@@ skipping 31 matching lines @@
       return new RetryRequestTestJob(
           request, network_delegate, RetryRequestTestJob::retry_headers(), 503);
     } else {
       return new RetryRequestTestJob(
           request,
           network_delegate,
           RetryRequestTestJob::manifest_headers(), 200);
     }
   }
 
-  virtual int GetResponseCode() const OVERRIDE { return response_code_; }
+  virtual int GetResponseCode() const override { return response_code_; }
 
  private:
   virtual ~RetryRequestTestJob() {}
 
   static std::string retry_headers() {
     const char no_retry_after[] =
         "HTTP/1.1 503 BOO HOO\0"
         "\0";
     const char nonzero[] =
         "HTTP/1.1 503 BOO HOO\0"
@@ skipping 43 matching lines @@
   static int num_retries_;
   static RetryHeader retry_after_;
   static int expected_requests_;
 };
 
 class RetryRequestTestJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return RetryRequestTestJob::RetryFactory(request, network_delegate);
   }
 };
 
 // static
 const GURL RetryRequestTestJob::kRetryUrl("http://retry");
 int RetryRequestTestJob::num_requests_ = 0;
 int RetryRequestTestJob::num_retries_;
 RetryRequestTestJob::RetryHeader RetryRequestTestJob::retry_after_;
 int RetryRequestTestJob::expected_requests_ = 0;
@@ skipping 59 matching lines @@
 bool HttpHeadersRequestTestJob::saw_if_modified_since_ = false;
 std::string HttpHeadersRequestTestJob::expect_if_none_match_;
 bool HttpHeadersRequestTestJob::saw_if_none_match_ = false;
 bool HttpHeadersRequestTestJob::already_checked_ = false;
 
 class IfModifiedSinceJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return HttpHeadersRequestTestJob::IfModifiedSinceFactory(
         request, network_delegate);
   }
 };
 
 class IOThread : public base::Thread {
  public:
   explicit IOThread(const char* name)
       : base::Thread(name) {
   }
 
   virtual ~IOThread() {
     Stop();
   }
 
   net::URLRequestContext* request_context() {
     return request_context_.get();
   }
 
   void SetNewJobFactory(net::URLRequestJobFactory* job_factory) {
     DCHECK(job_factory);
     job_factory_.reset(job_factory);
     request_context_->set_job_factory(job_factory_.get());
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     scoped_ptr<net::URLRequestJobFactoryImpl> factory(
         new net::URLRequestJobFactoryImpl());
     factory->SetProtocolHandler("http", new MockHttpServerJobFactory);
     factory->SetProtocolHandler("https", new MockHttpServerJobFactory);
     job_factory_ = factory.Pass();
     request_context_.reset(new net::TestURLRequestContext());
     request_context_->set_job_factory(job_factory_.get());
   }
 
-  virtual void CleanUp() OVERRIDE {
+  virtual void CleanUp() override {
     request_context_.reset();
     job_factory_.reset();
   }
 
  private:
   scoped_ptr<net::URLRequestJobFactory> job_factory_;
   scoped_ptr<net::URLRequestContext> request_context_;
 };
 
 class AppCacheUpdateJobTest : public testing::Test,
@@ skipping 2417 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void WaitForUpdateToFinish() {
     if (group_->update_status() == AppCacheGroup::IDLE)
       UpdateFinished();
     else
       group_->AddUpdateObserver(this);
   }
 
-  virtual void OnUpdateComplete(AppCacheGroup* group) OVERRIDE {
+  virtual void OnUpdateComplete(AppCacheGroup* group) override {
     ASSERT_EQ(group_.get(), group);
     protect_newest_cache_ = group->newest_complete_cache();
     UpdateFinished();
   }
 
   void UpdateFinished() {
     // We unwind the stack prior to finishing up to let stack-based objects
     // get deleted.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
@@ skipping 656 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content