Fixed clang/win build issues.

chrome/browser/printing/pdf_to_emf_converter.cc

 // Copyright 2014 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/browser/printing/pdf_to_emf_converter.h"
 
 #include <queue>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 17 matching lines @@
 class PdfToEmfConverterImpl;
 
 // Allows to delete temporary directory after all temporary files created inside
 // are closed. Windows cannot delete directory with opened files. Directory is
 // used to store PDF and metafiles. PDF should be gone by the time utility
 // process exits. Metafiles should be gone when all LazyEmf destroyed.
 class RefCountedTempDir
     : public base::RefCountedThreadSafe<RefCountedTempDir,
                                         BrowserThread::DeleteOnFileThread> {
  public:
-  RefCountedTempDir() { temp_dir_.CreateUniqueTempDir(); }
+  RefCountedTempDir() { ignore_result(temp_dir_.CreateUniqueTempDir()); }
   bool IsValid() const { return temp_dir_.IsValid(); }
   const base::FilePath& GetPath() const { return temp_dir_.path(); }
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::FILE>;
   friend class base::DeleteHelper<RefCountedTempDir>;
-  ~RefCountedTempDir() {};
+  ~RefCountedTempDir() {}
 
   base::ScopedTempDir temp_dir_;
   DISALLOW_COPY_AND_ASSIGN(RefCountedTempDir);
 };
 
 typedef scoped_ptr<base::File, BrowserThread::DeleteOnFileThread>
     ScopedTempFile;
 
 // Wrapper for Emf to keep only file handle in memory, and load actual data only
 // on playback. Emf::InitFromFile() can play metafile directly from disk, but it
@@ skipping 136 matching lines @@
   void RunCallback(const base::Closure& callback);
 
  private:
   scoped_refptr<PdfToEmfUtilityProcessHostClient> utility_client_;
   base::WeakPtrFactory<PdfToEmfConverterImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterImpl);
 };
 
 ScopedTempFile CreateTempFile(scoped_refptr<RefCountedTempDir>* temp_dir) {
-  if (!(*temp_dir))
+  if (!temp_dir->get())
     *temp_dir = new RefCountedTempDir();
   ScopedTempFile file;
   if (!(*temp_dir)->IsValid())
     return file.Pass();
   base::FilePath path;
   if (!base::CreateTemporaryFileInDir((*temp_dir)->GetPath(), &path))
     return file.Pass();
   file.reset(new base::File(path,
                             base::File::FLAG_CREATE_ALWAYS |
                             base::File::FLAG_WRITE |
@@ skipping 89 matching lines @@
     return OnFailed();
   // Should reply with OnProcessStarted().
   Send(new ChromeUtilityMsg_StartupPing);
 }
 
 void PdfToEmfUtilityProcessHostClient::OnProcessStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!utility_process_host_)
     return OnFailed();
 
-  base::ProcessHandle process = utility_process_host_->GetData().handle;
   scoped_refptr<base::RefCountedMemory> data = data_;
   data_ = NULL;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&CreateTempPdfFile, data, &temp_dir_),
       base::Bind(&PdfToEmfUtilityProcessHostClient::OnTempPdfReady, this));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnTempPdfReady(ScopedTempFile pdf) {
@@ skipping 61 matching lines @@
   // Should reply with OnPageDone().
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
       callback_data->page_number(), transit));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnPageDone(bool success,
                                                   double scale_factor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (get_page_callbacks_.empty())
     return OnFailed();
-  scoped_ptr<LazyEmf> emf;
+  scoped_ptr<MetafilePlayer> emf;
   GetPageCallbackData& data = get_page_callbacks_.front();
   if (success)
     emf.reset(new LazyEmf(temp_dir_, data.emf().Pass()));
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&PdfToEmfConverterImpl::RunCallback,
                                      converter_,
                                      base::Bind(data.callback(),
                                                 data.page_number(),
                                                 scale_factor,
@@ skipping 47 matching lines @@
     OnPageCount(0);
   while (!get_page_callbacks_.empty())
     OnPageDone(false, 0.0);
   utility_process_host_.reset();
 }
 
 PdfToEmfConverterImpl::PdfToEmfConverterImpl() : weak_ptr_factory_(this) {
 }
 
 PdfToEmfConverterImpl::~PdfToEmfConverterImpl() {
-  if (utility_client_)
+  if (utility_client_.get())
     utility_client_->Stop();
 }
 
 void PdfToEmfConverterImpl::Start(
     const scoped_refptr<base::RefCountedMemory>& data,
     const PdfRenderSettings& conversion_settings,
     const StartCallback& start_callback) {
-  DCHECK(!utility_client_);
+  DCHECK(!utility_client_.get());
   utility_client_ = new PdfToEmfUtilityProcessHostClient(
       weak_ptr_factory_.GetWeakPtr(), conversion_settings);
   utility_client_->Start(data, start_callback);
 }
 
 void PdfToEmfConverterImpl::GetPage(int page_number,
                                     const GetPageCallback& get_page_callback) {
   utility_client_->GetPage(page_number, get_page_callback);
 }
 
 void PdfToEmfConverterImpl::RunCallback(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback.Run();
 }
 
 }  // namespace
 
 PdfToEmfConverter::~PdfToEmfConverter() {
 }
 
 // static
 scoped_ptr<PdfToEmfConverter> PdfToEmfConverter::CreateDefault() {
   return scoped_ptr<PdfToEmfConverter>(new PdfToEmfConverterImpl());
 }
 
 }  // namespace printing