chrome/service/service_utility_process_host.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/service/service_utility_process_host.h"
   6
   7 #include <queue>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/files/file.h"
  12 #include "base/files/file_path.h"
  13 #include "base/files/file_util.h"
  14 #include "base/files/scoped_temp_dir.h"
  15 #include "base/logging.h"
  16 #include "base/message_loop/message_loop_proxy.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/process/kill.h"
  19 #include "base/process/launch.h"
  20 #include "base/task_runner_util.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/common/chrome_utility_printing_messages.h"
  23 #include "content/public/common/child_process_host.h"
  24 #include "content/public/common/result_codes.h"
  25 #include "content/public/common/sandbox_init.h"
  26 #include "content/public/common/sandboxed_process_launcher_delegate.h"
  27 #include "ipc/ipc_switches.h"
  28 #include "printing/emf_win.h"
  29 #include "sandbox/win/src/sandbox_policy_base.h"
  30 #include "ui/base/ui_base_switches.h"
  31
  32 namespace {
  33
  34 using content::ChildProcessHost;
  35
  36 enum ServiceUtilityProcessHostEvent {
  37   SERVICE_UTILITY_STARTED,
  38   SERVICE_UTILITY_DISCONNECTED,
  39   SERVICE_UTILITY_METAFILE_REQUEST,
  40   SERVICE_UTILITY_METAFILE_SUCCEEDED,
  41   SERVICE_UTILITY_METAFILE_FAILED,
  42   SERVICE_UTILITY_CAPS_REQUEST,
  43   SERVICE_UTILITY_CAPS_SUCCEEDED,
  44   SERVICE_UTILITY_CAPS_FAILED,
  45   SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST,
  46   SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED,
  47   SERVICE_UTILITY_SEMANTIC_CAPS_FAILED,
  48   SERVICE_UTILITY_FAILED_TO_START,
  49   SERVICE_UTILITY_EVENT_MAX,
  50 };
  51
  52 void ReportUmaEvent(ServiceUtilityProcessHostEvent id) {
  53   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
  54                             id,
  55                             SERVICE_UTILITY_EVENT_MAX);
  56 }
  57
  58 // NOTE: changes to this class need to be reviewed by the security team.
  59 class ServiceSandboxedProcessLauncherDelegate
  60     : public content::SandboxedProcessLauncherDelegate {
  61  public:
  62   ServiceSandboxedProcessLauncherDelegate() {}
  63
  64   virtual void PreSpawnTarget(sandbox::TargetPolicy* policy,
  65                               bool* success) OVERRIDE {
  66     // Service process may run as windows service and it fails to create a
  67     // window station.
  68     policy->SetAlternateDesktop(false);
  69   }
  70
  71  private:
  72   DISALLOW_COPY_AND_ASSIGN(ServiceSandboxedProcessLauncherDelegate);
  73 };
  74
  75 }  // namespace
  76
  77 class ServiceUtilityProcessHost::PdfToEmfState {
  78  public:
  79   explicit PdfToEmfState(ServiceUtilityProcessHost* host)
  80       : host_(host), page_count_(0), current_page_(0), pages_in_progress_(0) {}
  81   ~PdfToEmfState() { Stop(); }
  82
  83   bool Start(base::File pdf_file,
  84              const printing::PdfRenderSettings& conversion_settings) {
  85     if (!temp_dir_.CreateUniqueTempDir())
  86       return false;
  87     return host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
  88         IPC::TakeFileHandleForProcess(pdf_file.Pass(), host_->handle()),
  89         conversion_settings));
  90   }
  91
  92   void GetMorePages() {
  93     const int kMaxNumberOfTempFilesPerDocument = 3;
  94     while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
  95            current_page_ < page_count_) {
  96       ++pages_in_progress_;
  97       emf_files_.push(CreateTempFile());
  98       host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
  99           current_page_++,
 100           IPC::GetFileHandleForProcess(
 101               emf_files_.back().GetPlatformFile(), host_->handle(), false)));
 102     }
 103   }
 104
 105   // Returns true if all pages processed and client should not expect more
 106   // results.
 107   bool OnPageProcessed() {
 108     --pages_in_progress_;
 109     GetMorePages();
 110     if (pages_in_progress_ || current_page_ < page_count_)
 111       return false;
 112     Stop();
 113     return true;
 114   }
 115
 116   base::File TakeNextFile() {
 117     DCHECK(!emf_files_.empty());
 118     base::File file;
 119     if (!emf_files_.empty())
 120       file = emf_files_.front().Pass();
 121     emf_files_.pop();
 122     return file.Pass();
 123   }
 124
 125   void set_page_count(int page_count) { page_count_ = page_count; }
 126   bool has_page_count() { return page_count_ > 0; }
 127
 128  private:
 129   void Stop() {
 130     host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop());
 131   }
 132
 133   base::File CreateTempFile() {
 134     base::FilePath path;
 135     if (!base::CreateTemporaryFileInDir(temp_dir_.path(), &path))
 136       return base::File();
 137     return base::File(path,
 138                       base::File::FLAG_CREATE_ALWAYS |
 139                       base::File::FLAG_WRITE |
 140                       base::File::FLAG_READ |
 141                       base::File::FLAG_DELETE_ON_CLOSE |
 142                       base::File::FLAG_TEMPORARY);
 143   }
 144
 145   base::ScopedTempDir temp_dir_;
 146   ServiceUtilityProcessHost* host_;
 147   std::queue<base::File> emf_files_;
 148   int page_count_;
 149   int current_page_;
 150   int pages_in_progress_;
 151 };
 152
 153 ServiceUtilityProcessHost::ServiceUtilityProcessHost(
 154     Client* client,
 155     base::MessageLoopProxy* client_message_loop_proxy)
 156     : handle_(base::kNullProcessHandle),
 157       client_(client),
 158       client_message_loop_proxy_(client_message_loop_proxy),
 159       waiting_for_reply_(false),
 160       weak_ptr_factory_(this) {
 161   child_process_host_.reset(ChildProcessHost::Create(this));
 162 }
 163
 164 ServiceUtilityProcessHost::~ServiceUtilityProcessHost() {
 165   // We need to kill the child process when the host dies.
 166   base::KillProcess(handle_, content::RESULT_CODE_NORMAL_EXIT, false);
 167 }
 168
 169 bool ServiceUtilityProcessHost::StartRenderPDFPagesToMetafile(
 170     const base::FilePath& pdf_path,
 171     const printing::PdfRenderSettings& render_settings) {
 172   ReportUmaEvent(SERVICE_UTILITY_METAFILE_REQUEST);
 173   start_time_ = base::Time::Now();
 174   base::File pdf_file(pdf_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
 175   if (!pdf_file.IsValid() || !StartProcess(false))
 176     return false;
 177
 178   DCHECK(!waiting_for_reply_);
 179   waiting_for_reply_ = true;
 180
 181   pdf_to_emf_state_.reset(new PdfToEmfState(this));
 182   return pdf_to_emf_state_->Start(pdf_file.Pass(), render_settings);
 183 }
 184
 185 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
 186     const std::string& printer_name) {
 187   ReportUmaEvent(SERVICE_UTILITY_CAPS_REQUEST);
 188   start_time_ = base::Time::Now();
 189   if (!StartProcess(true))
 190     return false;
 191   DCHECK(!waiting_for_reply_);
 192   waiting_for_reply_ = true;
 193   return Send(new ChromeUtilityMsg_GetPrinterCapsAndDefaults(printer_name));
 194 }
 195
 196 bool ServiceUtilityProcessHost::StartGetPrinterSemanticCapsAndDefaults(
 197     const std::string& printer_name) {
 198   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST);
 199   start_time_ = base::Time::Now();
 200   if (!StartProcess(true))
 201     return false;
 202   DCHECK(!waiting_for_reply_);
 203   waiting_for_reply_ = true;
 204   return Send(
 205       new ChromeUtilityMsg_GetPrinterSemanticCapsAndDefaults(printer_name));
 206 }
 207
 208 bool ServiceUtilityProcessHost::StartProcess(bool no_sandbox) {
 209   std::string channel_id = child_process_host_->CreateChannel();
 210   if (channel_id.empty())
 211     return false;
 212
 213   base::FilePath exe_path = GetUtilityProcessCmd();
 214   if (exe_path.empty()) {
 215     NOTREACHED() << "Unable to get utility process binary name.";
 216     return false;
 217   }
 218
 219   base::CommandLine cmd_line(exe_path);
 220   cmd_line.AppendSwitchASCII(switches::kProcessType, switches::kUtilityProcess);
 221   cmd_line.AppendSwitchASCII(switches::kProcessChannelID, channel_id);
 222   cmd_line.AppendSwitch(switches::kLang);
 223
 224   if (Launch(&cmd_line, no_sandbox)) {
 225     ReportUmaEvent(SERVICE_UTILITY_STARTED);
 226     return true;
 227   }
 228   ReportUmaEvent(SERVICE_UTILITY_FAILED_TO_START);
 229   return false;
 230 }
 231
 232 bool ServiceUtilityProcessHost::Launch(base::CommandLine* cmd_line,
 233                                        bool no_sandbox) {
 234   if (no_sandbox) {
 235     base::ProcessHandle process = base::kNullProcessHandle;
 236     cmd_line->AppendSwitch(switches::kNoSandbox);
 237     base::LaunchProcess(*cmd_line, base::LaunchOptions(), &handle_);
 238   } else {
 239     ServiceSandboxedProcessLauncherDelegate delegate;
 240     handle_ = content::StartSandboxedProcess(&delegate, cmd_line);
 241   }
 242   return (handle_ != base::kNullProcessHandle);
 243 }
 244
 245 bool ServiceUtilityProcessHost::Send(IPC::Message* msg) {
 246   if (child_process_host_)
 247     return child_process_host_->Send(msg);
 248   delete msg;
 249   return false;
 250 }
 251
 252 base::FilePath ServiceUtilityProcessHost::GetUtilityProcessCmd() {
 253 #if defined(OS_LINUX)
 254   int flags = ChildProcessHost::CHILD_ALLOW_SELF;
 255 #else
 256   int flags = ChildProcessHost::CHILD_NORMAL;
 257 #endif
 258   return ChildProcessHost::GetChildPath(flags);
 259 }
 260
 261 void ServiceUtilityProcessHost::OnChildDisconnected() {
 262   if (waiting_for_reply_) {
 263     // If we are yet to receive a reply then notify the client that the
 264     // child died.
 265     client_message_loop_proxy_->PostTask(
 266         FROM_HERE, base::Bind(&Client::OnChildDied, client_.get()));
 267     ReportUmaEvent(SERVICE_UTILITY_DISCONNECTED);
 268     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityDisconnectTime",
 269                         base::Time::Now() - start_time_);
 270   }
 271   delete this;
 272 }
 273
 274 bool ServiceUtilityProcessHost::OnMessageReceived(const IPC::Message& message) {
 275   bool handled = true;
 276   IPC_BEGIN_MESSAGE_MAP(ServiceUtilityProcessHost, message)
 277     IPC_MESSAGE_HANDLER(
 278         ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount,
 279         OnRenderPDFPagesToMetafilesPageCount)
 280     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone,
 281                         OnRenderPDFPagesToMetafilesPageDone)
 282     IPC_MESSAGE_HANDLER(
 283         ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded,
 284         OnGetPrinterCapsAndDefaultsSucceeded)
 285     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Failed,
 286                         OnGetPrinterCapsAndDefaultsFailed)
 287     IPC_MESSAGE_HANDLER(
 288         ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded,
 289         OnGetPrinterSemanticCapsAndDefaultsSucceeded)
 290     IPC_MESSAGE_HANDLER(
 291         ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed,
 292         OnGetPrinterSemanticCapsAndDefaultsFailed)
 293     IPC_MESSAGE_UNHANDLED(handled = false)
 294   IPC_END_MESSAGE_MAP()
 295   return handled;
 296 }
 297
 298 base::ProcessHandle ServiceUtilityProcessHost::GetHandle() const {
 299   return handle_;
 300 }
 301
 302 void ServiceUtilityProcessHost::OnMetafileSpooled(bool success) {
 303   if (!success || pdf_to_emf_state_->OnPageProcessed())
 304     OnPDFToEmfFinished(success);
 305 }
 306
 307 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageCount(
 308     int page_count) {
 309   DCHECK(waiting_for_reply_);
 310   if (!pdf_to_emf_state_ || page_count <= 0 ||
 311       pdf_to_emf_state_->has_page_count()) {
 312     return OnPDFToEmfFinished(false);
 313   }
 314   pdf_to_emf_state_->set_page_count(page_count);
 315   pdf_to_emf_state_->GetMorePages();
 316 }
 317
 318 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageDone(
 319     bool success,
 320     double scale_factor) {
 321   DCHECK(waiting_for_reply_);
 322   if (!pdf_to_emf_state_ || !success)
 323     return OnPDFToEmfFinished(false);
 324   base::File emf_file = pdf_to_emf_state_->TakeNextFile();
 325   base::PostTaskAndReplyWithResult(
 326       client_message_loop_proxy_,
 327       FROM_HERE,
 328       base::Bind(&Client::MetafileAvailable,
 329                  client_.get(),
 330                  scale_factor,
 331                  base::Passed(&emf_file)),
 332       base::Bind(&ServiceUtilityProcessHost::OnMetafileSpooled,
 333                  weak_ptr_factory_.GetWeakPtr()));
 334 }
 335
 336 void ServiceUtilityProcessHost::OnPDFToEmfFinished(bool success) {
 337   if (!waiting_for_reply_)
 338     return;
 339   waiting_for_reply_ = false;
 340   if (success) {
 341     ReportUmaEvent(SERVICE_UTILITY_METAFILE_SUCCEEDED);
 342     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileTime",
 343                         base::Time::Now() - start_time_);
 344   } else {
 345     ReportUmaEvent(SERVICE_UTILITY_METAFILE_FAILED);
 346     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileFailTime",
 347                         base::Time::Now() - start_time_);
 348   }
 349   client_message_loop_proxy_->PostTask(
 350       FROM_HERE,
 351       base::Bind(
 352           &Client::OnRenderPDFPagesToMetafileDone, client_.get(), success));
 353   pdf_to_emf_state_.reset();
 354 }
 355
 356 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsSucceeded(
 357     const std::string& printer_name,
 358     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
 359   DCHECK(waiting_for_reply_);
 360   ReportUmaEvent(SERVICE_UTILITY_CAPS_SUCCEEDED);
 361   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsTime",
 362                       base::Time::Now() - start_time_);
 363   waiting_for_reply_ = false;
 364   client_message_loop_proxy_->PostTask(
 365       FROM_HERE,
 366       base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), true,
 367                  printer_name, caps_and_defaults));
 368 }
 369
 370 void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsSucceeded(
 371     const std::string& printer_name,
 372     const printing::PrinterSemanticCapsAndDefaults& caps_and_defaults) {
 373   DCHECK(waiting_for_reply_);
 374   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED);
 375   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsTime",
 376                       base::Time::Now() - start_time_);
 377   waiting_for_reply_ = false;
 378   client_message_loop_proxy_->PostTask(
 379       FROM_HERE,
 380       base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults, client_.get(),
 381                  true, printer_name, caps_and_defaults));
 382 }
 383
 384 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsFailed(
 385     const std::string& printer_name) {
 386   DCHECK(waiting_for_reply_);
 387   ReportUmaEvent(SERVICE_UTILITY_CAPS_FAILED);
 388   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsFailTime",
 389                       base::Time::Now() - start_time_);
 390   waiting_for_reply_ = false;
 391   client_message_loop_proxy_->PostTask(
 392       FROM_HERE,
 393       base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), false,
 394                  printer_name, printing::PrinterCapsAndDefaults()));
 395 }
 396
 397 void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsFailed(
 398     const std::string& printer_name) {
 399   DCHECK(waiting_for_reply_);
 400   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_FAILED);
 401   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsFailTime",
 402                       base::Time::Now() - start_time_);
 403   waiting_for_reply_ = false;
 404   client_message_loop_proxy_->PostTask(
 405       FROM_HERE,
 406       base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
 407                  client_.get(), false, printer_name,
 408                  printing::PrinterSemanticCapsAndDefaults()));
 409 }
 410
 411 bool ServiceUtilityProcessHost::Client::MetafileAvailable(double scale_factor,
 412                                                           base::File file) {
 413   file.Seek(base::File::FROM_BEGIN, 0);
 414   int64 size = file.GetLength();
 415   if (size <= 0) {
 416     OnRenderPDFPagesToMetafileDone(false);
 417     return false;
 418   }
 419   std::vector<char> data(size);
 420   if (file.ReadAtCurrentPos(data.data(), data.size()) != size) {
 421     OnRenderPDFPagesToMetafileDone(false);
 422     return false;
 423   }
 424   printing::Emf emf;
 425   if (!emf.InitFromData(data.data(), data.size())) {
 426     OnRenderPDFPagesToMetafileDone(false);
 427     return false;
 428   }
 429   OnRenderPDFPagesToMetafilePageDone(scale_factor, emf);
 430   return true;
 431 }