Use ScopedCOMInitializer in more places. While this doesn't always simplify code, it does mean we …

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 <objidl.h>
 #include <winspool.h>
 #include <xpsprint.h>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/object_watcher.h"
 #include "base/win/scoped_bstr.h"
+#include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_hdc.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/service/service_process.h"
 #include "chrome/service/service_utility_process_host.h"
 #include "grit/generated_resources.h"
 #include "printing/backend/print_backend.h"
 #include "printing/backend/print_backend_consts.h"
 #include "printing/backend/win_helper.h"
 #include "printing/emf_win.h"
@@ skipping 354 matching lines @@
    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) {
+            saved_dc_(0) {
       }
 
       ~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) {
@@ skipping 103 matching lines @@
                    (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;
-        }
+        if (done)
+          com_initializer_.reset();
       }
 
       virtual void OnRenderPDFPagesToMetafileFailed() OVERRIDE {
         PrintJobDone();
       }
 
       virtual void OnChildDied() OVERRIDE {
         PrintJobDone();
       }
 
@@ skipping 57 matching lines @@
 
       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,
-                                                    COINIT_MULTITHREADED));
+        scoped_ptr<base::win::ScopedCOMInitializer> com_initializer(
+            new base::win::ScopedCOMInitializer(
+                base::win::ScopedCOMInitializer::kMTA));
         base::win::ScopedComPtr<IXpsPrintJobStream> doc_stream;
         base::win::ScopedComPtr<IXpsPrintJobStream> print_ticket_stream;
         bool ret = false;
         // Use nested SUCCEEDED checks because we want a common return point.
         if (SUCCEEDED(printing::XPSPrintModule::StartXpsPrintJob(
                 UTF8ToWide(printer_name).c_str(),
                 UTF8ToWide(job_title).c_str(),
                 NULL,
                 job_progress_event_.Get(),
                 NULL,
@@ skipping 11 matching lines @@
               std::string document_data;
               file_util::ReadFileToString(print_data_file_path, &document_data);
               bytes_written = 0;
               if (SUCCEEDED(doc_stream->Write(document_data.c_str(),
                                               document_data.length(),
                                               &bytes_written))) {
                 DCHECK(bytes_written == document_data.length());
                 if (SUCCEEDED(doc_stream->Close())) {
                   job_progress_watcher_.StartWatching(job_progress_event_.Get(),
                                                       this);
+                  com_initializer_.swap(com_initializer);
                   ret = true;
                 }
               }
             }
           }
         }
         if (!ret) {
           if (xps_print_job_) {
             xps_print_job_->Cancel();
             xps_print_job_.Release();
           }
-          if (should_couninit_) {
-            CoUninitialize();
-            should_couninit_ = false;
-          }
         }
         return ret;
       }
 
       // Some Cairo-generated PDFs from Chrome OS result in huge metafiles.
       // So the PageCountPerBatch is set to 1 for now.
       // TODO(sanjeevr): Figure out a smarter way to determine the pages per
       // batch. Filed a bug to track this at
       // http://code.google.com/p/chromium/issues/detail?id=57350.
       static const int kPageCountPerBatch = 1;
       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_;
+      scoped_ptr<base::win::ScopedCOMInitializer> com_initializer_;
 
       DISALLOW_COPY_AND_ASSIGN(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.
@@ skipping 213 matching lines @@
   return "application/pdf";
 }
 
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print