Standardize usage of virtual/override/final in components/

components/component_updater/test/url_request_post_interceptor.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 "components/component_updater/test/url_request_post_interceptor.h"
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 13 matching lines @@
  public:
   URLRequestMockJob(net::URLRequest* request,
                     net::NetworkDelegate* network_delegate,
                     int response_code,
                     const std::string& response_body)
       : net::URLRequestSimpleJob(request, network_delegate),
         response_code_(response_code),
         response_body_(response_body) {}
 
  protected:
-  virtual int GetResponseCode() const override { return response_code_; }
+  int GetResponseCode() const override { return response_code_; }
 
-  virtual int GetData(std::string* mime_type,
-                      std::string* charset,
-                      std::string* data,
-                      const net::CompletionCallback& callback) const override {
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* data,
+              const net::CompletionCallback& callback) const override {
     mime_type->assign("text/plain");
     charset->assign("US-ASCII");
     data->assign(response_body_);
     return net::OK;
   }
 
  private:
-  virtual ~URLRequestMockJob() {}
+  ~URLRequestMockJob() override {}
 
   int response_code_;
   std::string response_body_;
   DISALLOW_COPY_AND_ASSIGN(URLRequestMockJob);
 };
 
 URLRequestPostInterceptor::URLRequestPostInterceptor(
     const GURL& url,
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : url_(url), io_task_runner_(io_task_runner), hit_count_(0) {
@@ skipping 104 matching lines @@
   }
 
   void OnCreateInterceptor(URLRequestPostInterceptor* interceptor) {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     DCHECK(interceptors_.find(interceptor->GetUrl()) == interceptors_.end());
 
     interceptors_.insert(std::make_pair(interceptor->GetUrl(), interceptor));
   }
 
  private:
-  virtual ~Delegate() {}
+  ~Delegate() override {}
 
-  virtual net::URLRequestJob* MaybeInterceptRequest(
+  net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
     // Only intercepts POST.
     if (!request->has_upload())
       return NULL;
 
     GURL url = request->url();
     if (url.has_query()) {
@@ skipping 112 matching lines @@
   return CreateInterceptorForPath(POST_INTERCEPT_PATH);
 }
 
 URLRequestPostInterceptor* InterceptorFactory::CreateInterceptorForPath(
     const char* url_path) {
   return URLRequestPostInterceptorFactory::CreateInterceptor(
       base::FilePath::FromUTF8Unsafe(url_path));
 }
 
 }  // namespace component_updater