replace OVERRIDE and FINAL with override and final in net/

net/url_request/url_request_file_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 "net/url_request/url_request_file_job.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 23 matching lines @@
                           file_task_runner),
         seek_position_(0) {
   }
 
   int64 seek_position() { return seek_position_; }
   const std::vector<std::string>& data_chunks() { return data_chunks_; }
 
  protected:
   virtual ~URLRequestFileJobWithCallbacks() {}
 
-  virtual void OnSeekComplete(int64 result) OVERRIDE {
+  virtual void OnSeekComplete(int64 result) override {
     ASSERT_EQ(seek_position_, 0);
     seek_position_ = result;
   }
 
-  virtual void OnReadComplete(IOBuffer* buf, int result) OVERRIDE {
+  virtual void OnReadComplete(IOBuffer* buf, int result) override {
     data_chunks_.push_back(std::string(buf->data(), result));
   }
 
   int64 seek_position_;
   std::vector<std::string> data_chunks_;
 };
 
 // A URLRequestJobFactory that will return URLRequestFileJobWithCallbacks
 // instances for file:// scheme URLs.
 class CallbacksJobFactory : public URLRequestJobFactory {
  public:
   class JobObserver {
    public:
     virtual void OnJobCreated(URLRequestFileJobWithCallbacks* job) = 0;
   };
 
   CallbacksJobFactory(const base::FilePath& path, JobObserver* observer)
       : path_(path), observer_(observer) {
   }
 
   virtual ~CallbacksJobFactory() {}
 
   virtual URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE {
+      NetworkDelegate* network_delegate) const override {
     URLRequestFileJobWithCallbacks* job = new URLRequestFileJobWithCallbacks(
         request,
         network_delegate,
         path_,
         base::MessageLoop::current()->message_loop_proxy());
     observer_->OnJobCreated(job);
     return job;
   }
 
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
+  virtual bool IsHandledProtocol(const std::string& scheme) const override {
     return scheme == "file";
   }
 
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
+  virtual bool IsHandledURL(const GURL& url) const override {
     return IsHandledProtocol(url.scheme());
   }
 
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   base::FilePath path_;
   JobObserver* observer_;
 };
 
 // Helper function to create a file in |directory| filled with
 // |content|. Returns true on succes and fills in |path| with the full path to
 // the file.
 bool CreateTempFileWithContent(const std::string& content,
                                const base::ScopedTempDir& directory,
                                base::FilePath* path) {
   if (!directory.IsValid())
     return false;
 
   if (!base::CreateTemporaryFileInDir(directory.path(), path))
     return false;
 
   return base::WriteFile(*path, content.c_str(), content.length());
 }
 
 class JobObserverImpl : public CallbacksJobFactory::JobObserver {
  public:
-  virtual void OnJobCreated(URLRequestFileJobWithCallbacks* job) OVERRIDE {
+  virtual void OnJobCreated(URLRequestFileJobWithCallbacks* job) override {
     jobs_.push_back(job);
   }
 
   typedef std::vector<scoped_refptr<URLRequestFileJobWithCallbacks> > JobList;
 
   const JobList& jobs() { return jobs_; }
 
  protected:
   JobList jobs_;
 };
@@ skipping 117 matching lines @@
   // Use a 15KB content file and read a range chosen somewhat arbitrarily but
   // not aligned on any likely page boundaries.
   int size = 15 * 1024;
   Range range(1701, (6 * 1024) + 3);
   RunRequest(MakeContentOfSize(size), &range);
 }
 
 }  // namespace
 
 }  // namespace net