Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

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>
 #if defined(_WIN32_WINNT)
 #undef _WIN32_WINNT
@@ skipping 13 matching lines @@
 #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"
 #include "printing/page_range.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 
-using base::win::ScopedBstr;
-using base::win::ScopedComPtr;
-
 namespace {
 
 class DevMode {
  public:
   DevMode() : dm_(NULL) {}
   ~DevMode() { Free(); }
 
   void Allocate(int size) {
     Free();
     dm_ = reinterpret_cast<DEVMODE*>(new char[size]);
@@ skipping 35 matching lines @@
 HRESULT PrintTicketToDevMode(const std::string& printer_name,
                              const std::string& print_ticket,
                              DevMode* dev_mode) {
   DCHECK(dev_mode);
   printing::ScopedXPSInitializer xps_initializer;
   if (!xps_initializer.initialized()) {
     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
     return E_FAIL;
   }
 
-  ScopedComPtr<IStream> pt_stream;
+  base::win::ScopedComPtr<IStream> pt_stream;
   HRESULT hr = StreamFromPrintTicket(print_ticket, pt_stream.Receive());
   if (FAILED(hr))
     return hr;
 
   HPTPROVIDER provider = NULL;
   hr = printing::XPSModule::OpenProvider(UTF8ToWide(printer_name),
                                          1,
                                          &provider);
   if (SUCCEEDED(hr)) {
     ULONG size = 0;
@@ skipping 453 matching lines @@
                             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));
-        ScopedComPtr<IXpsPrintJobStream> doc_stream;
-        ScopedComPtr<IXpsPrintJobStream> print_ticket_stream;
+        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,
                 NULL,
                 NULL,
@@ skipping 42 matching lines @@
       // 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::ScopedHDC printer_dc_;
       FilePath print_data_file_path_;
       base::win::ScopedHandle job_progress_event_;
       base::win::ObjectWatcher job_progress_watcher_;
-      ScopedComPtr<IXpsPrintJob> xps_print_job_;
+      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 {
@@ skipping 110 matching lines @@
   if (!xps_initializer.initialized()) {
     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
     return false;
   }
   bool ret = false;
   HPTPROVIDER provider = NULL;
   printing::XPSModule::OpenProvider(UTF8ToWide(printer_name.c_str()),
                                     1,
                                     &provider);
   if (provider) {
-    ScopedComPtr<IStream> print_ticket_stream;
+    base::win::ScopedComPtr<IStream> print_ticket_stream;
     CreateStreamOnHGlobal(NULL, TRUE, print_ticket_stream.Receive());
     ULONG bytes_written = 0;
     print_ticket_stream->Write(print_ticket_data.c_str(),
                                print_ticket_data.length(),
                                &bytes_written);
     DCHECK(bytes_written == print_ticket_data.length());
     LARGE_INTEGER pos = {0};
     ULARGE_INTEGER new_pos = {0};
     print_ticket_stream->Seek(pos, STREAM_SEEK_SET, &new_pos);
-    ScopedBstr error;
-    ScopedComPtr<IStream> result_ticket_stream;
+    base::win::ScopedBstr error;
+    base::win::ScopedComPtr<IStream> result_ticket_stream;
     CreateStreamOnHGlobal(NULL, TRUE, result_ticket_stream.Receive());
     ret = SUCCEEDED(printing::XPSModule::MergeAndValidatePrintTicket(
         provider,
         print_ticket_stream.get(),
         NULL,
         kPTJobScope,
         result_ticket_stream.get(),
         error.Receive()));
     printing::XPSModule::CloseProvider(provider);
   }
@@ skipping 80 matching lines @@
   RpcStringFree(reinterpret_cast<RPC_WSTR *>(&proxy_id_as_string));
   return ret;
 }
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print