base::Bind: Convert chrome/service/cloud_print.

chrome/service/cloud_print/print_system_win.cc

 // Copyright (c) 2011 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 <objidl.h>
 #include <winspool.h>
 #include <xpsprint.h>
 
@@ skipping 233 matching lines @@
 // Visual Studio where it gets confused between multiple Delegate.
 // In this case, some compilers get confused and inherit
 // PrintSystemWin watchers from wrong Delegate, giving C2664 and C2259 errors.
 typedef PrintSystemWatcherWin::Delegate PrintSystemWatcherWinDelegate;
 
 class PrintSystemWin : public PrintSystem {
  public:
   PrintSystemWin();
 
   // PrintSystem implementation.
-  virtual PrintSystemResult Init();
-
+  virtual PrintSystemResult Init() OVERRIDE;
   virtual PrintSystem::PrintSystemResult EnumeratePrinters(
-      printing::PrinterList* printer_list);
-
+      printing::PrinterList* printer_list) OVERRIDE;
   virtual void GetPrinterCapsAndDefaults(
       const std::string& printer_name,
-      PrinterCapsAndDefaultsCallback* callback);
-
-  virtual bool IsValidPrinter(const std::string& printer_name);
-
-  virtual bool ValidatePrintTicket(const std::string& printer_name,
-                                   const std::string& print_ticket_data);
-
+      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) OVERRIDE;
   virtual bool GetJobDetails(const std::string& printer_name,
                              PlatformJobId job_id,
-                             PrintJobDetails *job_details);
+                             PrintJobDetails *job_details) OVERRIDE;
 
   class PrintServerWatcherWin
     : public PrintSystem::PrintServerWatcher,
       public PrintSystemWatcherWinDelegate {
    public:
     PrintServerWatcherWin() : delegate_(NULL) {}
 
-    // PrintSystem::PrintServerWatcher interface
+    // PrintSystem::PrintServerWatcher implementation.
     virtual bool StartWatching(
-        PrintSystem::PrintServerWatcher::Delegate* delegate) {
+        PrintSystem::PrintServerWatcher::Delegate* delegate) OVERRIDE{
       delegate_ = delegate;
       return watcher_.Start(std::string(), this);
     }
-    virtual bool StopWatching() {
+
+    virtual bool StopWatching() OVERRIDE{
       bool ret = watcher_.Stop();
       delegate_ = NULL;
       return ret;
     }
 
-    // PrintSystemWatcherWin::Delegate interface
-    virtual void OnPrinterAdded() {
+    // PrintSystemWatcherWin::Delegate implementation.
+    virtual void OnPrinterAdded() OVERRIDE {
       delegate_->OnPrinterAdded();
     }
-    virtual void OnPrinterDeleted() {
-    }
-    virtual void OnPrinterChanged() {
-    }
-    virtual void OnJobChanged() {
-    }
+    virtual void OnPrinterDeleted() OVERRIDE {}
+    virtual void OnPrinterChanged() OVERRIDE {}
+    virtual void OnJobChanged() OVERRIDE {}
 
    private:
     PrintSystem::PrintServerWatcher::Delegate* delegate_;
     PrintSystemWatcherWin watcher_;
+
     DISALLOW_COPY_AND_ASSIGN(PrintServerWatcherWin);
   };
 
   class PrinterWatcherWin
       : public PrintSystem::PrinterWatcher,
         public PrintSystemWatcherWinDelegate {
    public:
      explicit PrinterWatcherWin(const std::string& printer_name)
          : printer_name_(printer_name),
            delegate_(NULL) {
      }
 
-    // PrintSystem::PrinterWatcher interface
+    // PrintSystem::PrinterWatcher implementation.
     virtual bool StartWatching(
-        PrintSystem::PrinterWatcher::Delegate* delegate) {
+        PrintSystem::PrinterWatcher::Delegate* delegate) OVERRIDE {
       delegate_ = delegate;
       return watcher_.Start(printer_name_, this);
     }
-    virtual bool StopWatching() {
+
+    virtual bool StopWatching() OVERRIDE {
       bool ret = watcher_.Stop();
       delegate_ = NULL;
       return ret;
     }
+
     virtual bool GetCurrentPrinterInfo(
-        printing::PrinterBasicInfo* printer_info) {
+        printing::PrinterBasicInfo* printer_info) OVERRIDE {
       return watcher_.GetCurrentPrinterInfo(printer_info);
     }
 
-    // PrintSystemWatcherWin::Delegate interface
-    virtual void OnPrinterAdded() {
+    // PrintSystemWatcherWin::Delegate implementation.
+    virtual void OnPrinterAdded() OVERRIDE {
       NOTREACHED();
     }
-    virtual void OnPrinterDeleted() {
+    virtual void OnPrinterDeleted() OVERRIDE {
       delegate_->OnPrinterDeleted();
     }
-    virtual void OnPrinterChanged() {
+    virtual void OnPrinterChanged() OVERRIDE {
       delegate_->OnPrinterChanged();
     }
-    virtual void OnJobChanged() {
+    virtual void OnJobChanged() OVERRIDE {
       delegate_->OnJobChanged();
     }
 
    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 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) {
+                       JobSpooler::Delegate* delegate) OVERRIDE {
       // TODO(gene): add tags handling.
       return core_->Spool(print_ticket, print_data_file_path,
                           print_data_mime_type, printer_name, job_title,
                           delegate);
     }
 
    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()
           : last_page_printed_(-1),
             job_id_(-1),
             delegate_(NULL),
             saved_dc_(0),
             should_couninit_(false) {
       }
-      ~Core() {
-      }
+
+      ~Core() {}
+
       bool Spool(const std::string& print_ticket,
                  const 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.
           NOTREACHED();
           return false;
@@ skipping 55 matching lines @@
         } else {
           NOTREACHED();
           return false;
         }
         return true;
       }
 
       // ServiceUtilityProcessHost::Client implementation.
       virtual void OnRenderPDFPagesToMetafileSucceeded(
           const printing::Emf& metafile,
-          int highest_rendered_page_number) {
+          int highest_rendered_page_number) OVERRIDE {
         metafile.SafePlayback(printer_dc_.Get());
         bool done_printing = (highest_rendered_page_number !=
             last_page_printed_ + kPageCountPerBatch);
         last_page_printed_ = highest_rendered_page_number;
         if (done_printing)
           PrintJobDone();
         else
           RenderNextPDFPages();
       }
 
-      // base::win::ObjectWatcher::Delegate inplementation.
-      virtual void OnObjectSignaled(HANDLE object) {
+      // base::win::ObjectWatcher::Delegate implementation.
+      virtual void OnObjectSignaled(HANDLE object) OVERRIDE {
         DCHECK(xps_print_job_);
         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);
         bool done = false;
         if ((job_status.completion == XPS_JOB_CANCELLED) ||
             (job_status.completion == XPS_JOB_FAILED)) {
           delegate_->OnJobSpoolFailed();
           done = true;
         } else if (job_status.jobId ||
                    (job_status.completion == XPS_JOB_COMPLETED)) {
           // Note: In the case of the XPS document being printed to the
           // Microsoft XPS Document Writer, it seems to skip spooling the job
           // and goes to the completed state without ever assigning a job id.
           delegate_->OnJobSpoolSucceeded(job_status.jobId);
           done = true;
         } else {
           job_progress_watcher_.StopWatching();
           job_progress_watcher_.StartWatching(job_progress_event_.Get(), this);
         }
         if (done && should_couninit_) {
           CoUninitialize();
           should_couninit_ = false;
         }
       }
 
-      virtual void OnRenderPDFPagesToMetafileFailed() {
+      virtual void OnRenderPDFPagesToMetafileFailed() OVERRIDE {
         PrintJobDone();
       }
-      virtual void OnChildDied() {
+
+      virtual void OnChildDied() OVERRIDE {
         PrintJobDone();
       }
+
      private:
       void PrintJobDone() {
         // If there is no delegate, then there is nothing pending to process.
         if (!delegate_)
           return;
         RestoreDC(printer_dc_.Get(), saved_dc_);
         EndDoc(printer_dc_.Get());
         if (-1 == last_page_printed_) {
           delegate_->OnJobSpoolFailed();
         } else {
           delegate_->OnJobSpoolSucceeded(job_id_);
         }
         delegate_ = NULL;
       }
+
       void RenderNextPDFPages() {
         printing::PageRange range;
         // Render 10 pages at a time.
         range.from = last_page_printed_ + 1;
         range.to = last_page_printed_ + kPageCountPerBatch;
         std::vector<printing::PageRange> page_ranges;
         page_ranges.push_back(range);
 
         int printer_dpi = ::GetDeviceCaps(printer_dc_.Get(), LOGPIXELSX);
         int dc_width = GetDeviceCaps(printer_dc_.Get(), PHYSICALWIDTH);
         int dc_height = GetDeviceCaps(printer_dc_.Get(), PHYSICALHEIGHT);
         gfx::Rect render_area(0, 0, dc_width, dc_height);
         g_service_process->io_thread()->message_loop_proxy()->PostTask(
             FROM_HERE,
             base::Bind(&JobSpoolerWin::Core::RenderPDFPagesInSandbox, this,
                        print_data_file_path_, render_area, printer_dpi,
                        page_ranges, base::MessageLoopProxy::current()));
       }
+
       // Called on the service process IO thread.
       void RenderPDFPagesInSandbox(
           const FilePath& pdf_path, const gfx::Rect& render_area,
           int render_dpi, const std::vector<printing::PageRange>& page_ranges,
           const scoped_refptr<base::MessageLoopProxy>&
               client_message_loop_proxy) {
         DCHECK(g_service_process->io_thread()->message_loop_proxy()->
             BelongsToCurrentThread());
         scoped_ptr<ServiceUtilityProcessHost> utility_host(
             new ServiceUtilityProcessHost(this, client_message_loop_proxy));
         // TODO(gene): For now we disabling autorotation for CloudPrinting.
         // Landscape/Portrait setting is passed in the print ticket and
         // server is generating portrait PDF always.
         // We should enable autorotation once server will be able to generate
         // PDF that matches paper size and orientation.
         if (utility_host->StartRenderPDFPagesToMetafile(
                 pdf_path,
                 printing::PdfRenderSettings(render_area, render_dpi, false),
                 page_ranges)) {
           // The object will self-destruct when the child process dies.
           utility_host.release();
         }
       }
+
       bool PrintXPSDocument(const std::string& printer_name,
                             const std::string& job_title,
                             const FilePath& print_data_file_path,
                             const std::string& print_ticket) {
         if (!printing::XPSPrintModule::Init())
           return false;
         job_progress_event_.Set(CreateEvent(NULL, TRUE, FALSE, NULL));
         if (!job_progress_event_.Get())
           return false;
         should_couninit_ = SUCCEEDED(CoInitializeEx(NULL,
@@ skipping 57 matching lines @@
       int last_page_printed_;
       PlatformJobId job_id_;
       PrintSystem::JobSpooler::Delegate* delegate_;
       int saved_dc_;
       base::win::ScopedCreateDC printer_dc_;
       FilePath print_data_file_path_;
       base::win::ScopedHandle job_progress_event_;
       base::win::ObjectWatcher job_progress_watcher_;
       base::win::ScopedComPtr<IXpsPrintJob> xps_print_job_;
       bool should_couninit_;
+
       DISALLOW_COPY_AND_ASSIGN(JobSpoolerWin::Core);
     };
     scoped_refptr<Core> core_;
+
     DISALLOW_COPY_AND_ASSIGN(JobSpoolerWin);
   };
 
   // A helper class to handle the response from the utility process to the
   // request to fetch printer capabilities and defaults.
   class PrinterCapsHandler : public ServiceUtilityProcessHost::Client {
    public:
     PrinterCapsHandler(
         const std::string& printer_name,
-        PrinterCapsAndDefaultsCallback* callback)
+        const PrinterCapsAndDefaultsCallback& callback)
             : printer_name_(printer_name), callback_(callback) {
     }
-    virtual void Start() {
+
+    // ServiceUtilityProcessHost::Client implementation.
+    virtual void OnChildDied() OVERRIDE {
+      OnGetPrinterCapsAndDefaultsFailed(printer_name_);
+    }
+
+    virtual void OnGetPrinterCapsAndDefaultsSucceeded(
+        const std::string& printer_name,
+        const printing::PrinterCapsAndDefaults& caps_and_defaults) OVERRIDE {
+      callback_.Run(true, printer_name, caps_and_defaults);
+      callback_.Reset();
+      Release();
+    }
+
+    virtual void OnGetPrinterCapsAndDefaultsFailed(
+        const std::string& printer_name) OVERRIDE {
+      printing::PrinterCapsAndDefaults caps_and_defaults;
+      callback_.Run(false, printer_name, caps_and_defaults);
+      callback_.Reset();
+      Release();
+    }
+
+    void Start() {
       g_service_process->io_thread()->message_loop_proxy()->PostTask(
           FROM_HERE,
           base::Bind(&PrinterCapsHandler::GetPrinterCapsAndDefaultsImpl, this,
                      base::MessageLoopProxy::current()));
     }
 
-    virtual void OnChildDied() {
-      OnGetPrinterCapsAndDefaultsFailed(printer_name_);
-    }
-    virtual void OnGetPrinterCapsAndDefaultsSucceeded(
-        const std::string& printer_name,
-        const printing::PrinterCapsAndDefaults& caps_and_defaults) {
-      callback_->Run(true, printer_name, caps_and_defaults);
-      callback_.reset();
-      Release();
-    }
-
-    virtual void OnGetPrinterCapsAndDefaultsFailed(
-        const std::string& printer_name) {
-      printing::PrinterCapsAndDefaults caps_and_defaults;
-      callback_->Run(false, printer_name, caps_and_defaults);
-      callback_.reset();
-      Release();
-    }
-
    private:
       // Called on the service process IO thread.
     void GetPrinterCapsAndDefaultsImpl(
         const scoped_refptr<base::MessageLoopProxy>&
             client_message_loop_proxy) {
       DCHECK(g_service_process->io_thread()->message_loop_proxy()->
           BelongsToCurrentThread());
       scoped_ptr<ServiceUtilityProcessHost> utility_host(
           new ServiceUtilityProcessHost(this, client_message_loop_proxy));
       if (utility_host->StartGetPrinterCapsAndDefaults(printer_name_)) {
         // The object will self-destruct when the child process dies.
         utility_host.release();
       } else {
         client_message_loop_proxy->PostTask(
             FROM_HERE,
             base::Bind(&PrinterCapsHandler::OnGetPrinterCapsAndDefaultsFailed,
                        this, printer_name_));
       }
     }
 
     std::string printer_name_;
-    scoped_ptr<PrinterCapsAndDefaultsCallback> callback_;
+    PrinterCapsAndDefaultsCallback callback_;
   };
 
 
-  virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher();
+  virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() OVERRIDE;
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
-      const std::string& printer_name);
-  virtual PrintSystem::JobSpooler* CreateJobSpooler();
-  virtual std::string GetSupportedMimeTypes();
-
+      const std::string& printer_name) OVERRIDE;
+  virtual PrintSystem::JobSpooler* CreateJobSpooler() OVERRIDE;
+  virtual std::string GetSupportedMimeTypes() OVERRIDE;
 
  private:
   scoped_refptr<printing::PrintBackend> print_backend_;
 };
 
 PrintSystemWin::PrintSystemWin() {
   print_backend_ = printing::PrintBackend::CreateInstance(NULL);
 }
 
 PrintSystem::PrintSystemResult PrintSystemWin::Init() {
   if (!printing::XPSModule::Init()) {
     std::string message = l10n_util::GetStringUTF8(
         IDS_CLOUD_PRINT_XPS_UNAVAILABLE);
     return PrintSystemResult(false, message);
   }
   return PrintSystemResult(true, std::string());
 }
 
 PrintSystem::PrintSystemResult PrintSystemWin::EnumeratePrinters(
     printing::PrinterList* printer_list) {
   bool ret = print_backend_->EnumeratePrinters(printer_list);
   return PrintSystemResult(ret, std::string());
 }
 
 void PrintSystemWin::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
-    PrinterCapsAndDefaultsCallback* callback) {
+    const PrinterCapsAndDefaultsCallback& callback) {
   // Launch as child process to retrieve the capabilities and defaults because
   // this involves invoking a printer driver DLL and crashes have been known to
   // occur.
   PrinterCapsHandler* handler =
       new PrinterCapsHandler(printer_name, callback);
   handler->AddRef();
   handler->Start();
 }
 
 bool PrintSystemWin::IsValidPrinter(const std::string& printer_name) {
@@ skipping 119 matching lines @@
   RpcStringFree(reinterpret_cast<RPC_WSTR *>(&proxy_id_as_string));
   return ret;
 }
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print