Give names to all utility processes.

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"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/chrome_utility_printing_messages.h"
+#include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "printing/emf_win.h"
 #include "printing/pdf_render_settings.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace printing {
 
 namespace {
 
 using content::BrowserThread;
 
 class PdfToEmfConverterImpl;
 
 // Allows to delete temporary directory after all temporary files created inside
@@ skipping 23 matching lines @@
 // 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
 // can't open file handles. We need file handles to reliably delete temporary
 // files, and to efficiently interact with utility process.
 class LazyEmf : public MetafilePlayer {
  public:
   LazyEmf(const scoped_refptr<RefCountedTempDir>& temp_dir, ScopedTempFile file)
       : temp_dir_(temp_dir), file_(file.Pass()) {}
   virtual ~LazyEmf() { Close(); }
 
-  virtual bool SafePlayback(HDC hdc) const override;
-  virtual bool SaveTo(base::File* file) const override;
+  bool SafePlayback(HDC hdc) const override;
+  bool SaveTo(base::File* file) const override;
 
  private:
   void Close() const;
   bool LoadEmf(Emf* emf) const;
 
   mutable scoped_refptr<RefCountedTempDir> temp_dir_;
   mutable ScopedTempFile file_;  // Mutable because of consts in base class.
 
   DISALLOW_COPY_AND_ASSIGN(LazyEmf);
 };
@@ skipping 20 matching lines @@
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              const PdfToEmfConverter::StartCallback& start_callback);
 
   void GetPage(int page_number,
                const PdfToEmfConverter::GetPageCallback& get_page_callback);
 
   void Stop();
 
   // UtilityProcessHostClient implementation.
-  virtual void OnProcessCrashed(int exit_code) override;
-  virtual void OnProcessLaunchFailed() override;
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  void OnProcessCrashed(int exit_code) override;
+  void OnProcessLaunchFailed() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
  private:
   class GetPageCallbackData {
     MOVE_ONLY_TYPE_FOR_CPP_03(GetPageCallbackData, RValue);
 
    public:
     GetPageCallbackData(int page_number,
                         PdfToEmfConverter::GetPageCallback callback)
         : page_number_(page_number), callback_(callback) {}
 
@@ skipping 55 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfUtilityProcessHostClient);
 };
 
 class PdfToEmfConverterImpl : public PdfToEmfConverter {
  public:
   PdfToEmfConverterImpl();
 
   virtual ~PdfToEmfConverterImpl();
 
-  virtual void Start(const scoped_refptr<base::RefCountedMemory>& data,
-                     const PdfRenderSettings& conversion_settings,
-                     const StartCallback& start_callback) override;
+  void Start(const scoped_refptr<base::RefCountedMemory>& data,
+             const PdfRenderSettings& conversion_settings,
+             const StartCallback& start_callback) override;
 
-  virtual void GetPage(int page_number,
-                       const GetPageCallback& get_page_callback) override;
+  void GetPage(int page_number,
+               const GetPageCallback& get_page_callback) override;
 
   // Helps to cancel callbacks if this object is destroyed.
   void RunCallback(const base::Closure& callback);
 
  private:
   scoped_refptr<PdfToEmfUtilityProcessHostClient> utility_client_;
   base::WeakPtrFactory<PdfToEmfConverterImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterImpl);
 };
@@ skipping 91 matching lines @@
   // Store callback before any OnFailed() call to make it called on failure.
   start_callback_ = start_callback;
 
   // NOTE: This process _must_ be sandboxed, otherwise the pdf dll will load
   // gdiplus.dll, change how rendering happens, and not be able to correctly
   // generate when sent to a metafile DC.
   utility_process_host_ =
       content::UtilityProcessHost::Create(
           this, base::MessageLoop::current()->message_loop_proxy())
           ->AsWeakPtr();
-  if (!utility_process_host_)
-    return OnFailed();
+  utility_process_host_->SetName(l10n_util::GetStringUTF16(
+      IDS_UTILITY_PROCESS_EMF_CONVERTOR_NAME));
   // Should reply with OnProcessStarted().
   Send(new ChromeUtilityMsg_StartupPing);
 }
 
 void PdfToEmfUtilityProcessHostClient::OnProcessStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!utility_process_host_)
     return OnFailed();
 
   scoped_refptr<base::RefCountedMemory> data = data_;
@@ skipping 173 matching lines @@
 
 PdfToEmfConverter::~PdfToEmfConverter() {
 }
 
 // static
 scoped_ptr<PdfToEmfConverter> PdfToEmfConverter::CreateDefault() {
   return scoped_ptr<PdfToEmfConverter>(new PdfToEmfConverterImpl());
 }
 
 }  // namespace printing