Replacing the OVERRIDE with override and FINAL with final in chrome/service

chrome/service/cloud_print/print_system_win.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.
 
 #include "chrome/service/cloud_print/print_system.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 122 matching lines @@
 };
 
 class PrintServerWatcherWin
   : public PrintSystem::PrintServerWatcher,
     public PrintSystemWatcherWin::Delegate {
  public:
   PrintServerWatcherWin() : delegate_(NULL) {}
 
   // PrintSystem::PrintServerWatcher implementation.
   virtual bool StartWatching(
-      PrintSystem::PrintServerWatcher::Delegate* delegate) OVERRIDE{
+      PrintSystem::PrintServerWatcher::Delegate* delegate) override{
     delegate_ = delegate;
     return watcher_.Start(std::string(), this);
   }
 
-  virtual bool StopWatching() OVERRIDE{
+  virtual bool StopWatching() override{
     bool ret = watcher_.Stop();
     delegate_ = NULL;
     return ret;
   }
 
   // PrintSystemWatcherWin::Delegate implementation.
-  virtual void OnPrinterAdded() OVERRIDE {
+  virtual void OnPrinterAdded() override {
     delegate_->OnPrinterAdded();
   }
-  virtual void OnPrinterDeleted() OVERRIDE {}
-  virtual void OnPrinterChanged() OVERRIDE {}
-  virtual void OnJobChanged() OVERRIDE {}
+  virtual void OnPrinterDeleted() override {}
+  virtual void OnPrinterChanged() override {}
+  virtual void OnJobChanged() override {}
 
  protected:
   virtual ~PrintServerWatcherWin() {}
 
  private:
   PrintSystem::PrintServerWatcher::Delegate* delegate_;
   PrintSystemWatcherWin watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(PrintServerWatcherWin);
 };
 
 class PrinterWatcherWin
     : public PrintSystem::PrinterWatcher,
       public PrintSystemWatcherWin::Delegate {
  public:
   explicit PrinterWatcherWin(const std::string& printer_name)
       : printer_name_(printer_name),
         delegate_(NULL) {
   }
 
   // PrintSystem::PrinterWatcher implementation.
   virtual bool StartWatching(
-      PrintSystem::PrinterWatcher::Delegate* delegate) OVERRIDE {
+      PrintSystem::PrinterWatcher::Delegate* delegate) override {
     delegate_ = delegate;
     return watcher_.Start(printer_name_, this);
   }
 
-  virtual bool StopWatching() OVERRIDE {
+  virtual bool StopWatching() override {
     bool ret = watcher_.Stop();
     delegate_ = NULL;
     return ret;
   }
 
   virtual bool GetCurrentPrinterInfo(
-      printing::PrinterBasicInfo* printer_info) OVERRIDE {
+      printing::PrinterBasicInfo* printer_info) override {
     return watcher_.GetCurrentPrinterInfo(printer_info);
   }
 
   // PrintSystemWatcherWin::Delegate implementation.
-  virtual void OnPrinterAdded() OVERRIDE {
+  virtual void OnPrinterAdded() override {
     NOTREACHED();
   }
-  virtual void OnPrinterDeleted() OVERRIDE {
+  virtual void OnPrinterDeleted() override {
     delegate_->OnPrinterDeleted();
   }
-  virtual void OnPrinterChanged() OVERRIDE {
+  virtual void OnPrinterChanged() override {
     delegate_->OnPrinterChanged();
   }
-  virtual void OnJobChanged() OVERRIDE {
+  virtual void OnJobChanged() override {
     delegate_->OnJobChanged();
   }
 
  protected:
   virtual ~PrinterWatcherWin() {}
 
  private:
   std::string printer_name_;
   PrintSystem::PrinterWatcher::Delegate* delegate_;
   PrintSystemWatcherWin watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(PrinterWatcherWin);
 };
 
 class JobSpoolerWin : public PrintSystem::JobSpooler {
  public:
   JobSpoolerWin() : core_(new Core) {}
 
   // PrintSystem::JobSpooler implementation.
   virtual bool Spool(const std::string& print_ticket,
                      const std::string& print_ticket_mime_type,
                      const base::FilePath& print_data_file_path,
                      const std::string& print_data_mime_type,
                      const std::string& printer_name,
                      const std::string& job_title,
                      const std::vector<std::string>& tags,
-                     JobSpooler::Delegate* delegate) OVERRIDE {
+                     JobSpooler::Delegate* delegate) override {
     // TODO(gene): add tags handling.
     scoped_refptr<printing::PrintBackend> print_backend(
         printing::PrintBackend::CreateInstance(NULL));
     crash_keys::ScopedPrinterInfo crash_key(
         print_backend->GetPrinterDriverInfo(printer_name));
     return core_->Spool(print_ticket, print_ticket_mime_type,
                         print_data_file_path, print_data_mime_type,
                         printer_name, job_title, delegate);
   }
 
@@ skipping 85 matching lines @@
       XFORM xform = {0};
       xform.eDx = static_cast<float>(-offset_x);
       xform.eDy = static_cast<float>(-offset_y);
       xform.eM11 = xform.eM22 = 1.0 / scale_factor;
       SetWorldTransform(printer_dc_.Get(), &xform);
     }
 
     // ServiceUtilityProcessHost::Client implementation.
     virtual void OnRenderPDFPagesToMetafilePageDone(
         double scale_factor,
-        const printing::MetafilePlayer& emf) OVERRIDE {
+        const printing::MetafilePlayer& emf) override {
       PreparePageDCForPrinting(printer_dc_.Get(), scale_factor);
       ::StartPage(printer_dc_.Get());
       emf.SafePlayback(printer_dc_.Get());
       ::EndPage(printer_dc_.Get());
     }
 
     // ServiceUtilityProcessHost::Client implementation.
-    virtual void OnRenderPDFPagesToMetafileDone(bool success) OVERRIDE {
+    virtual void OnRenderPDFPagesToMetafileDone(bool success) override {
       PrintJobDone(success);
     }
 
-    virtual void OnChildDied() OVERRIDE { PrintJobDone(false); }
+    virtual void OnChildDied() override { PrintJobDone(false); }
 
     // base::win::ObjectWatcher::Delegate implementation.
-    virtual void OnObjectSignaled(HANDLE object) OVERRIDE {
+    virtual void OnObjectSignaled(HANDLE object) override {
   // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
       tracked_objects::ScopedProfile tracking_profile(
           FROM_HERE_WITH_EXPLICIT_FUNCTION(
               "Core_OnObjectSignaled"));
 
       DCHECK(xps_print_job_);
       DCHECK(object == job_progress_event_.Get());
       ResetEvent(job_progress_event_.Get());
       if (!delegate_)
         return;
@@ skipping 159 matching lines @@
 // request to fetch printer capabilities and defaults.
 class PrinterCapsHandler : public ServiceUtilityProcessHost::Client {
  public:
   PrinterCapsHandler(
       const std::string& printer_name,
       const PrintSystem::PrinterCapsAndDefaultsCallback& callback)
           : printer_name_(printer_name), callback_(callback) {
   }
 
   // ServiceUtilityProcessHost::Client implementation.
-  virtual void OnChildDied() OVERRIDE {
+  virtual void OnChildDied() override {
     OnGetPrinterCapsAndDefaults(false, printer_name_,
                                 printing::PrinterCapsAndDefaults());
   }
 
   virtual void OnGetPrinterCapsAndDefaults(
       bool succeeded,
       const std::string& printer_name,
-      const printing::PrinterCapsAndDefaults& caps_and_defaults) OVERRIDE {
+      const printing::PrinterCapsAndDefaults& caps_and_defaults) override {
     callback_.Run(succeeded, printer_name, caps_and_defaults);
     callback_.Reset();
     Release();
   }
 
   virtual void OnGetPrinterSemanticCapsAndDefaults(
       bool succeeded,
       const std::string& printer_name,
-      const printing::PrinterSemanticCapsAndDefaults& semantic_info) OVERRIDE {
+      const printing::PrinterSemanticCapsAndDefaults& semantic_info) override {
     printing::PrinterCapsAndDefaults printer_info;
     if (succeeded) {
       printer_info.caps_mime_type = kContentTypeJSON;
       scoped_ptr<base::DictionaryValue> description(
           PrinterSemanticCapsAndDefaultsToCdd(semantic_info));
       if (description) {
         base::JSONWriter::WriteWithOptions(
             description.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT,
             &printer_info.printer_capabilities);
       }
@@ skipping 54 matching lines @@
 
   std::string printer_name_;
   PrintSystem::PrinterCapsAndDefaultsCallback callback_;
 };
 
 class PrintSystemWin : public PrintSystem {
  public:
   PrintSystemWin();
 
   // PrintSystem implementation.
-  virtual PrintSystemResult Init() OVERRIDE;
+  virtual PrintSystemResult Init() override;
   virtual PrintSystem::PrintSystemResult EnumeratePrinters(
-      printing::PrinterList* printer_list) OVERRIDE;
+      printing::PrinterList* printer_list) override;
   virtual void GetPrinterCapsAndDefaults(
       const std::string& printer_name,
-      const PrinterCapsAndDefaultsCallback& callback) OVERRIDE;
-  virtual bool IsValidPrinter(const std::string& printer_name) OVERRIDE;
+      const PrinterCapsAndDefaultsCallback& callback) override;
+  virtual bool IsValidPrinter(const std::string& printer_name) override;
   virtual bool ValidatePrintTicket(
       const std::string& printer_name,
       const std::string& print_ticket_data,
-      const std::string& print_ticket_data_mime_type) OVERRIDE;
+      const std::string& print_ticket_data_mime_type) override;
   virtual bool GetJobDetails(const std::string& printer_name,
                              PlatformJobId job_id,
-                             PrintJobDetails *job_details) OVERRIDE;
-  virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() OVERRIDE;
+                             PrintJobDetails *job_details) override;
+  virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() override;
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
-      const std::string& printer_name) OVERRIDE;
-  virtual PrintSystem::JobSpooler* CreateJobSpooler() OVERRIDE;
-  virtual bool UseCddAndCjt() OVERRIDE;
-  virtual std::string GetSupportedMimeTypes() OVERRIDE;
+      const std::string& printer_name) override;
+  virtual PrintSystem::JobSpooler* CreateJobSpooler() override;
+  virtual bool UseCddAndCjt() override;
+  virtual std::string GetSupportedMimeTypes() override;
 
  private:
   std::string PrintSystemWin::GetPrinterDriverInfo(
       const std::string& printer_name) const;
 
   scoped_refptr<printing::PrintBackend> print_backend_;
   bool use_cdd_;
   DISALLOW_COPY_AND_ASSIGN(PrintSystemWin);
 };
 
@@ skipping 171 matching lines @@
 }
 
 }  // namespace
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print