replace OVERRIDE and FINAL with override and final in net/

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 410 matching lines @@
         domain_(domain),
         path_(path),
         expiration_time_(expiration_time),
         secure_(secure),
         http_only_(http_only),
         priority_(priority),
         callback_(callback) {
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~SetCookieWithDetailsTask() {}
 
  private:
   GURL url_;
   std::string name_;
   std::string value_;
   std::string domain_;
   std::string path_;
@@ skipping 19 matching lines @@
 // Task class for GetAllCookies call.
 class CookieMonster::GetAllCookiesTask : public CookieMonsterTask {
  public:
   GetAllCookiesTask(CookieMonster* cookie_monster,
                     const GetCookieListCallback& callback)
       : CookieMonsterTask(cookie_monster),
         callback_(callback) {
   }
 
   // CookieMonsterTask
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~GetAllCookiesTask() {}
 
  private:
   GetCookieListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetAllCookiesTask);
 };
 
@@ skipping 14 matching lines @@
       const GURL& url,
       const CookieOptions& options,
       const GetCookieListCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
         callback_(callback) {
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~GetAllCookiesForURLWithOptionsTask() {}
 
  private:
   GURL url_;
   CookieOptions options_;
   GetCookieListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetAllCookiesForURLWithOptionsTask);
@@ skipping 20 matching lines @@
 template <typename Result>
 class CookieMonster::DeleteTask : public CookieMonsterTask {
  public:
   DeleteTask(CookieMonster* cookie_monster,
              const typename CallbackType<Result>::Type& callback)
       : CookieMonsterTask(cookie_monster),
         callback_(callback) {
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   // Runs the delete task and returns a result.
   virtual Result RunDeleteTask() = 0;
   base::Closure RunDeleteTaskAndBindCallback();
   void FlushDone(const base::Closure& callback);
 
   typename CallbackType<Result>::Type callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteTask);
@@ skipping 31 matching lines @@
 
 // Task class for DeleteAll call.
 class CookieMonster::DeleteAllTask : public DeleteTask<int> {
  public:
   DeleteAllTask(CookieMonster* cookie_monster,
                 const DeleteCallback& callback)
       : DeleteTask<int>(cookie_monster, callback) {
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllTask() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeleteAllTask);
 };
 
 int CookieMonster::DeleteAllTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteAll(true);
 }
 
 // Task class for DeleteAllCreatedBetween call.
 class CookieMonster::DeleteAllCreatedBetweenTask : public DeleteTask<int> {
  public:
   DeleteAllCreatedBetweenTask(CookieMonster* cookie_monster,
                               const Time& delete_begin,
                               const Time& delete_end,
                               const DeleteCallback& callback)
       : DeleteTask<int>(cookie_monster, callback),
         delete_begin_(delete_begin),
         delete_end_(delete_end) {
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllCreatedBetweenTask() {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenTask);
 };
 
 int CookieMonster::DeleteAllCreatedBetweenTask::RunDeleteTask() {
   return this->cookie_monster()->
       DeleteAllCreatedBetween(delete_begin_, delete_end_);
 }
 
 // Task class for DeleteAllForHost call.
 class CookieMonster::DeleteAllForHostTask : public DeleteTask<int> {
  public:
   DeleteAllForHostTask(CookieMonster* cookie_monster,
                        const GURL& url,
                        const DeleteCallback& callback)
       : DeleteTask<int>(cookie_monster, callback),
         url_(url) {
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllForHostTask() {}
 
  private:
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllForHostTask);
 };
 
@@ skipping 11 matching lines @@
       Time delete_end,
       const GURL& url,
       const DeleteCallback& callback)
       : DeleteTask<int>(cookie_monster, callback),
         delete_begin_(delete_begin),
         delete_end_(delete_end),
         url_(url) {
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllCreatedBetweenForHostTask() {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenForHostTask);
 };
 
 int CookieMonster::DeleteAllCreatedBetweenForHostTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteAllCreatedBetweenForHost(
       delete_begin_, delete_end_, url_);
 }
 
 // Task class for DeleteCanonicalCookie call.
 class CookieMonster::DeleteCanonicalCookieTask : public DeleteTask<bool> {
  public:
   DeleteCanonicalCookieTask(CookieMonster* cookie_monster,
                             const CanonicalCookie& cookie,
                             const DeleteCookieCallback& callback)
       : DeleteTask<bool>(cookie_monster, callback),
         cookie_(cookie) {
   }
 
   // DeleteTask:
-  virtual bool RunDeleteTask() OVERRIDE;
+  virtual bool RunDeleteTask() override;
 
  protected:
   virtual ~DeleteCanonicalCookieTask() {}
 
  private:
   CanonicalCookie cookie_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCanonicalCookieTask);
 };
 
@@ skipping 10 matching lines @@
                            const CookieOptions& options,
                            const SetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         cookie_line_(cookie_line),
         options_(options),
         callback_(callback) {
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~SetCookieWithOptionsTask() {}
 
  private:
   GURL url_;
   std::string cookie_line_;
   CookieOptions options_;
   SetCookiesCallback callback_;
 
@@ skipping 16 matching lines @@
                             const GURL& url,
                             const CookieOptions& options,
                             const GetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
         callback_(callback) {
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~GetCookiesWithOptionsTask() {}
 
  private:
   GURL url_;
   CookieOptions options_;
   GetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookiesWithOptionsTask);
@@ skipping 14 matching lines @@
   DeleteCookieTask(CookieMonster* cookie_monster,
                    const GURL& url,
                    const std::string& cookie_name,
                    const base::Closure& callback)
       : DeleteTask<void>(cookie_monster, callback),
         url_(url),
         cookie_name_(cookie_name) {
   }
 
   // DeleteTask:
-  virtual void RunDeleteTask() OVERRIDE;
+  virtual void RunDeleteTask() override;
 
  protected:
   virtual ~DeleteCookieTask() {}
 
  private:
   GURL url_;
   std::string cookie_name_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCookieTask);
 };
 
 void CookieMonster::DeleteCookieTask::RunDeleteTask() {
   this->cookie_monster()->DeleteCookie(url_, cookie_name_);
 }
 
 // Task class for DeleteSessionCookies call.
 class CookieMonster::DeleteSessionCookiesTask : public DeleteTask<int> {
  public:
   DeleteSessionCookiesTask(CookieMonster* cookie_monster,
                            const DeleteCallback& callback)
       : DeleteTask<int>(cookie_monster, callback) {
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteSessionCookiesTask() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeleteSessionCookiesTask);
 };
 
 int CookieMonster::DeleteSessionCookiesTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteSessionCookies();
 }
 
 // Task class for HasCookiesForETLDP1Task call.
 class CookieMonster::HasCookiesForETLDP1Task : public CookieMonsterTask {
  public:
   HasCookiesForETLDP1Task(
       CookieMonster* cookie_monster,
       const std::string& etldp1,
       const HasCookiesForETLDP1Callback& callback)
       : CookieMonsterTask(cookie_monster),
         etldp1_(etldp1),
         callback_(callback) {
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~HasCookiesForETLDP1Task() {}
 
  private:
   std::string etldp1_;
   HasCookiesForETLDP1Callback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(HasCookiesForETLDP1Task);
 };
@@ skipping 1418 matching lines @@
 
   return true;
 }
 
 bool CookieMonster::loaded() {
   base::AutoLock autolock(lock_);
   return loaded_;
 }
 
 }  // namespace net