Update {virtual,override} to follow C++11 style in chrome.

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 115 matching lines @@
   std::string printer_info_;     // For crash reporting.
 };
 
 class PrintServerWatcherWin
   : public PrintSystem::PrintServerWatcher,
     public PrintSystemWatcherWin::Delegate {
  public:
   PrintServerWatcherWin() : delegate_(NULL) {}
 
   // PrintSystem::PrintServerWatcher implementation.
-  virtual bool StartWatching(
-      PrintSystem::PrintServerWatcher::Delegate* delegate) override{
+  bool StartWatching(
+      PrintSystem::PrintServerWatcher::Delegate* delegate) override {
     delegate_ = delegate;
     return watcher_.Start(std::string(), this);
   }
 
-  virtual bool StopWatching() override{
+  bool StopWatching() override {
     bool ret = watcher_.Stop();
     delegate_ = NULL;
     return ret;
   }
 
   // PrintSystemWatcherWin::Delegate implementation.
-  virtual void OnPrinterAdded() override {
+  void OnPrinterAdded() override {
     delegate_->OnPrinterAdded();
   }
-  virtual void OnPrinterDeleted() override {}
-  virtual void OnPrinterChanged() override {}
-  virtual void OnJobChanged() override {}
+  void OnPrinterDeleted() override {}
+  void OnPrinterChanged() override {}
+  void OnJobChanged() override {}
 
  protected:
-  virtual ~PrintServerWatcherWin() {}
+  ~PrintServerWatcherWin() override {}
 
  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 {
+  bool StartWatching(PrintSystem::PrinterWatcher::Delegate* delegate) override {
     delegate_ = delegate;
     return watcher_.Start(printer_name_, this);
   }
 
-  virtual bool StopWatching() override {
+  bool StopWatching() override {
     bool ret = watcher_.Stop();
     delegate_ = NULL;
     return ret;
   }
 
-  virtual bool GetCurrentPrinterInfo(
+  bool GetCurrentPrinterInfo(
       printing::PrinterBasicInfo* printer_info) override {
     return watcher_.GetCurrentPrinterInfo(printer_info);
   }
 
   // PrintSystemWatcherWin::Delegate implementation.
-  virtual void OnPrinterAdded() override {
+  void OnPrinterAdded() override {
     NOTREACHED();
   }
-  virtual void OnPrinterDeleted() override {
+  void OnPrinterDeleted() override {
     delegate_->OnPrinterDeleted();
   }
-  virtual void OnPrinterChanged() override {
+  void OnPrinterChanged() override {
     delegate_->OnPrinterChanged();
   }
-  virtual void OnJobChanged() override {
+  void OnJobChanged() override {
     delegate_->OnJobChanged();
   }
 
  protected:
-  virtual ~PrinterWatcherWin() {}
+  ~PrinterWatcherWin() override {}
 
  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 {
+  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 {
     // 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);
   }
 
  protected:
-  virtual ~JobSpoolerWin() {}
+  ~JobSpoolerWin() override {}
 
  private:
   // We use a Core class because we want a separate RefCountedThreadSafe
   // implementation for ServiceUtilityProcessHost::Client.
   class Core : public ServiceUtilityProcessHost::Client,
                public base::win::ObjectWatcher::Delegate {
    public:
     Core() : job_id_(-1), delegate_(NULL), saved_dc_(0) {}
 
-    ~Core() {}
+    ~Core() override {}
 
     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,
                JobSpooler::Delegate* delegate) {
       if (delegate_) {
         // We are already in the process of printing.
@@ skipping 61 matching lines @@
       int offset_x = ::GetDeviceCaps(printer_dc_.Get(), PHYSICALOFFSETX);
       int offset_y = ::GetDeviceCaps(printer_dc_.Get(), PHYSICALOFFSETY);
       XFORM xform = {0};
       xform.eDx = static_cast<float>(-offset_x);
       xform.eDy = static_cast<float>(-offset_y);
       xform.eM11 = xform.eM22 = 1.0f / scale_factor;
       SetWorldTransform(printer_dc_.Get(), &xform);
     }
 
     // ServiceUtilityProcessHost::Client implementation.
-    virtual void OnRenderPDFPagesToMetafilePageDone(
+    void OnRenderPDFPagesToMetafilePageDone(
         float scale_factor,
         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 {
+    void OnRenderPDFPagesToMetafileDone(bool success) override {
       PrintJobDone(success);
     }
 
-    virtual void OnChildDied() override { PrintJobDone(false); }
+    void OnChildDied() override { PrintJobDone(false); }
 
     // base::win::ObjectWatcher::Delegate implementation.
-    virtual void OnObjectSignaled(HANDLE object) override {
+    void OnObjectSignaled(HANDLE object) override {
       DCHECK(xps_print_job_.get());
       DCHECK(object == job_progress_event_.Get());
       ResetEvent(job_progress_event_.Get());
       if (!delegate_)
         return;
       XPS_JOB_STATUS job_status = {0};
       xps_print_job_->GetJobStatus(&job_status);
       if ((job_status.completion == XPS_JOB_CANCELLED) ||
           (job_status.completion == XPS_JOB_FAILED)) {
         delegate_->OnJobSpoolFailed();
@@ skipping 154 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 {
+  void OnChildDied() override {
     OnGetPrinterCapsAndDefaults(false, printer_name_,
                                 printing::PrinterCapsAndDefaults());
   }
 
-  virtual void OnGetPrinterCapsAndDefaults(
+  void OnGetPrinterCapsAndDefaults(
       bool succeeded,
       const std::string& printer_name,
       const printing::PrinterCapsAndDefaults& caps_and_defaults) override {
     callback_.Run(succeeded, printer_name, caps_and_defaults);
     callback_.Reset();
     Release();
   }
 
-  virtual void OnGetPrinterSemanticCapsAndDefaults(
+  void OnGetPrinterSemanticCapsAndDefaults(
       bool succeeded,
       const std::string& printer_name,
       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(
@@ skipping 57 matching lines @@
 
   std::string printer_name_;
   PrintSystem::PrinterCapsAndDefaultsCallback callback_;
 };
 
 class PrintSystemWin : public PrintSystem {
  public:
   PrintSystemWin();
 
   // PrintSystem implementation.
-  virtual PrintSystemResult Init() override;
-  virtual PrintSystem::PrintSystemResult EnumeratePrinters(
+  PrintSystemResult Init() override;
+  PrintSystem::PrintSystemResult EnumeratePrinters(
       printing::PrinterList* printer_list) override;
-  virtual void GetPrinterCapsAndDefaults(
+  void GetPrinterCapsAndDefaults(
       const std::string& printer_name,
       const PrinterCapsAndDefaultsCallback& callback) override;
-  virtual bool IsValidPrinter(const std::string& printer_name) override;
-  virtual bool ValidatePrintTicket(
+  bool IsValidPrinter(const std::string& printer_name) override;
+  bool ValidatePrintTicket(
       const std::string& printer_name,
       const std::string& print_ticket_data,
       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;
-  virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
+  bool GetJobDetails(const std::string& printer_name,
+                     PlatformJobId job_id,
+                     PrintJobDetails* job_details) override;
+  PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() override;
+  PrintSystem::PrinterWatcher* CreatePrinterWatcher(
       const std::string& printer_name) override;
-  virtual PrintSystem::JobSpooler* CreateJobSpooler() override;
-  virtual bool UseCddAndCjt() override;
-  virtual std::string GetSupportedMimeTypes() override;
+  PrintSystem::JobSpooler* CreateJobSpooler() override;
+  bool UseCddAndCjt() override;
+  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