chrome/utility/chrome_content_utility_client.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/utility/chrome_content_utility_client.h"
   6
   7 #include "base/base64.h"
   8 #include "base/bind.h"
   9 #include "base/command_line.h"
  10 #include "base/file_util.h"
  11 #include "base/files/file_path.h"
  12 #include "base/json/json_reader.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/path_service.h"
  16 #include "base/scoped_native_library.h"
  17 #include "base/time/time.h"
  18 #include "chrome/common/chrome_paths.h"
  19 #include "chrome/common/chrome_utility_messages.h"
  20 #include "chrome/common/extensions/chrome_extensions_client.h"
  21 #include "chrome/common/extensions/extension_l10n_util.h"
  22 #include "chrome/common/extensions/update_manifest.h"
  23 #include "chrome/common/safe_browsing/zip_analyzer.h"
  24 #include "chrome/utility/cloud_print/bitmap_image.h"
  25 #include "chrome/utility/cloud_print/pwg_encoder.h"
  26 #include "chrome/utility/extensions/unpacker.h"
  27 #include "chrome/utility/profile_import_handler.h"
  28 #include "chrome/utility/web_resource_unpacker.h"
  29 #include "content/public/child/image_decoder_utils.h"
  30 #include "content/public/common/content_paths.h"
  31 #include "content/public/utility/utility_thread.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/manifest.h"
  34 #include "media/base/media.h"
  35 #include "media/base/media_file_checker.h"
  36 #include "printing/page_range.h"
  37 #include "printing/pdf_render_settings.h"
  38 #include "third_party/skia/include/core/SkBitmap.h"
  39 #include "third_party/zlib/google/zip.h"
  40 #include "ui/base/ui_base_switches.h"
  41 #include "ui/gfx/codec/jpeg_codec.h"
  42 #include "ui/gfx/rect.h"
  43 #include "ui/gfx/size.h"
  44
  45 #if defined(OS_WIN)
  46 #include "base/win/iat_patch_function.h"
  47 #include "base/win/scoped_handle.h"
  48 #include "chrome/utility/media_galleries/itunes_pref_parser_win.h"
  49 #include "printing/emf_win.h"
  50 #include "ui/gfx/gdi_util.h"
  51 #endif  // defined(OS_WIN)
  52
  53 #if defined(OS_MACOSX)
  54 #include "chrome/utility/media_galleries/iphoto_library_parser.h"
  55 #endif  // defined(OS_MACOSX)
  56
  57 #if defined(OS_WIN) || defined(OS_MACOSX)
  58 #include "chrome/utility/media_galleries/iapps_xml_utils.h"
  59 #include "chrome/utility/media_galleries/itunes_library_parser.h"
  60 #include "chrome/utility/media_galleries/picasa_album_table_reader.h"
  61 #include "chrome/utility/media_galleries/picasa_albums_indexer.h"
  62 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
  63
  64 #if defined(ENABLE_FULL_PRINTING)
  65 #include "chrome/common/crash_keys.h"
  66 #include "printing/backend/print_backend.h"
  67 #endif
  68
  69 #if defined(ENABLE_MDNS)
  70 #include "chrome/utility/local_discovery/service_discovery_message_handler.h"
  71 #include "content/public/common/content_switches.h"
  72 #endif  // ENABLE_MDNS
  73
  74 namespace chrome {
  75
  76 namespace {
  77
  78 bool Send(IPC::Message* message) {
  79   return content::UtilityThread::Get()->Send(message);
  80 }
  81
  82 void ReleaseProcessIfNeeded() {
  83   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
  84 }
  85
  86 class PdfFunctionsBase {
  87  public:
  88   PdfFunctionsBase() : render_pdf_to_bitmap_func_(NULL),
  89                        get_pdf_doc_info_func_(NULL) {}
  90
  91   bool Init() {
  92     base::FilePath pdf_module_path;
  93     if (!PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_module_path) ||
  94         !base::PathExists(pdf_module_path)) {
  95       return false;
  96     }
  97
  98     pdf_lib_.Reset(base::LoadNativeLibrary(pdf_module_path, NULL));
  99     if (!pdf_lib_.is_valid()) {
 100       LOG(WARNING) << "Couldn't load PDF plugin";
 101       return false;
 102     }
 103
 104     render_pdf_to_bitmap_func_ =
 105         reinterpret_cast<RenderPDFPageToBitmapProc>(
 106             pdf_lib_.GetFunctionPointer("RenderPDFPageToBitmap"));
 107     LOG_IF(WARNING, !render_pdf_to_bitmap_func_) <<
 108         "Missing RenderPDFPageToBitmap";
 109
 110     get_pdf_doc_info_func_ =
 111         reinterpret_cast<GetPDFDocInfoProc>(
 112             pdf_lib_.GetFunctionPointer("GetPDFDocInfo"));
 113     LOG_IF(WARNING, !get_pdf_doc_info_func_) << "Missing GetPDFDocInfo";
 114
 115     if (!render_pdf_to_bitmap_func_ || !get_pdf_doc_info_func_ ||
 116         !PlatformInit(pdf_module_path, pdf_lib_)) {
 117       Reset();
 118     }
 119
 120     return IsValid();
 121   }
 122
 123   bool IsValid() const {
 124     return pdf_lib_.is_valid();
 125   }
 126
 127   void Reset() {
 128     pdf_lib_.Reset(NULL);
 129   }
 130
 131   bool RenderPDFPageToBitmap(const void* pdf_buffer,
 132                              int pdf_buffer_size,
 133                              int page_number,
 134                              void* bitmap_buffer,
 135                              int bitmap_width,
 136                              int bitmap_height,
 137                              int dpi_x,
 138                              int dpi_y,
 139                              bool autorotate) {
 140     if (!render_pdf_to_bitmap_func_)
 141       return false;
 142     return render_pdf_to_bitmap_func_(pdf_buffer, pdf_buffer_size, page_number,
 143                                       bitmap_buffer, bitmap_width,
 144                                       bitmap_height, dpi_x, dpi_y, autorotate);
 145   }
 146
 147   bool GetPDFDocInfo(const void* pdf_buffer,
 148                      int buffer_size,
 149                      int* page_count,
 150                      double* max_page_width) {
 151     if (!get_pdf_doc_info_func_)
 152       return false;
 153     return get_pdf_doc_info_func_(pdf_buffer, buffer_size, page_count,
 154                                   max_page_width);
 155   }
 156
 157  protected:
 158   virtual bool PlatformInit(
 159       const base::FilePath& pdf_module_path,
 160       const base::ScopedNativeLibrary& pdf_lib) {
 161     return true;
 162   };
 163
 164  private:
 165   // Exported by PDF plugin.
 166   typedef bool (*RenderPDFPageToBitmapProc)(const void* pdf_buffer,
 167                                             int pdf_buffer_size,
 168                                             int page_number,
 169                                             void* bitmap_buffer,
 170                                             int bitmap_width,
 171                                             int bitmap_height,
 172                                             int dpi_x,
 173                                             int dpi_y,
 174                                             bool autorotate);
 175   typedef bool (*GetPDFDocInfoProc)(const void* pdf_buffer,
 176                                     int buffer_size, int* page_count,
 177                                     double* max_page_width);
 178
 179   RenderPDFPageToBitmapProc render_pdf_to_bitmap_func_;
 180   GetPDFDocInfoProc get_pdf_doc_info_func_;
 181
 182   base::ScopedNativeLibrary pdf_lib_;
 183   DISALLOW_COPY_AND_ASSIGN(PdfFunctionsBase);
 184 };
 185
 186 #if defined(OS_WIN)
 187 // The 2 below IAT patch functions are almost identical to the code in
 188 // render_process_impl.cc. This is needed to work around specific Windows APIs
 189 // used by the Chrome PDF plugin that will fail in the sandbox.
 190 static base::win::IATPatchFunction g_iat_patch_createdca;
 191 HDC WINAPI UtilityProcess_CreateDCAPatch(LPCSTR driver_name,
 192                                          LPCSTR device_name,
 193                                          LPCSTR output,
 194                                          const DEVMODEA* init_data) {
 195   if (driver_name && (std::string("DISPLAY") == driver_name)) {
 196     // CreateDC fails behind the sandbox, but not CreateCompatibleDC.
 197     return CreateCompatibleDC(NULL);
 198   }
 199
 200   NOTREACHED();
 201   return CreateDCA(driver_name, device_name, output, init_data);
 202 }
 203
 204 static base::win::IATPatchFunction g_iat_patch_get_font_data;
 205 DWORD WINAPI UtilityProcess_GetFontDataPatch(
 206     HDC hdc, DWORD table, DWORD offset, LPVOID buffer, DWORD length) {
 207   int rv = GetFontData(hdc, table, offset, buffer, length);
 208   if (rv == GDI_ERROR && hdc) {
 209     HFONT font = static_cast<HFONT>(GetCurrentObject(hdc, OBJ_FONT));
 210
 211     LOGFONT logfont;
 212     if (GetObject(font, sizeof(LOGFONT), &logfont)) {
 213       content::UtilityThread::Get()->PreCacheFont(logfont);
 214       rv = GetFontData(hdc, table, offset, buffer, length);
 215       content::UtilityThread::Get()->ReleaseCachedFonts();
 216     }
 217   }
 218   return rv;
 219 }
 220
 221 class PdfFunctionsWin : public PdfFunctionsBase {
 222  public:
 223   PdfFunctionsWin() : render_pdf_to_dc_func_(NULL) {
 224   }
 225
 226   bool PlatformInit(
 227       const base::FilePath& pdf_module_path,
 228       const base::ScopedNativeLibrary& pdf_lib) OVERRIDE {
 229     // Patch the IAT for handling specific APIs known to fail in the sandbox.
 230     if (!g_iat_patch_createdca.is_patched()) {
 231       g_iat_patch_createdca.Patch(pdf_module_path.value().c_str(),
 232                                   "gdi32.dll", "CreateDCA",
 233                                   UtilityProcess_CreateDCAPatch);
 234     }
 235
 236     if (!g_iat_patch_get_font_data.is_patched()) {
 237       g_iat_patch_get_font_data.Patch(pdf_module_path.value().c_str(),
 238                                       "gdi32.dll", "GetFontData",
 239                                       UtilityProcess_GetFontDataPatch);
 240     }
 241     render_pdf_to_dc_func_ =
 242       reinterpret_cast<RenderPDFPageToDCProc>(
 243           pdf_lib.GetFunctionPointer("RenderPDFPageToDC"));
 244     LOG_IF(WARNING, !render_pdf_to_dc_func_) << "Missing RenderPDFPageToDC";
 245
 246     return render_pdf_to_dc_func_ != NULL;
 247   }
 248
 249   bool RenderPDFPageToDC(const void* pdf_buffer,
 250                          int buffer_size,
 251                          int page_number,
 252                          HDC dc,
 253                          int dpi_x,
 254                          int dpi_y,
 255                          int bounds_origin_x,
 256                          int bounds_origin_y,
 257                          int bounds_width,
 258                          int bounds_height,
 259                          bool fit_to_bounds,
 260                          bool stretch_to_bounds,
 261                          bool keep_aspect_ratio,
 262                          bool center_in_bounds,
 263                          bool autorotate) {
 264     if (!render_pdf_to_dc_func_)
 265       return false;
 266     return render_pdf_to_dc_func_(pdf_buffer, buffer_size, page_number,
 267                                   dc, dpi_x, dpi_y, bounds_origin_x,
 268                                   bounds_origin_y, bounds_width, bounds_height,
 269                                   fit_to_bounds, stretch_to_bounds,
 270                                   keep_aspect_ratio, center_in_bounds,
 271                                   autorotate);
 272   }
 273
 274  private:
 275   // Exported by PDF plugin.
 276   typedef bool (*RenderPDFPageToDCProc)(
 277       const void* pdf_buffer, int buffer_size, int page_number, HDC dc,
 278       int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y,
 279       int bounds_width, int bounds_height, bool fit_to_bounds,
 280       bool stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds,
 281       bool autorotate);
 282   RenderPDFPageToDCProc render_pdf_to_dc_func_;
 283
 284   DISALLOW_COPY_AND_ASSIGN(PdfFunctionsWin);
 285 };
 286
 287 typedef PdfFunctionsWin PdfFunctions;
 288 #else  // OS_WIN
 289 typedef PdfFunctionsBase PdfFunctions;
 290 #endif  // OS_WIN
 291
 292 static base::LazyInstance<PdfFunctions> g_pdf_lib = LAZY_INSTANCE_INITIALIZER;
 293
 294 }  // namespace
 295
 296 ChromeContentUtilityClient::ChromeContentUtilityClient() {
 297 #if !defined(OS_ANDROID)
 298   handlers_.push_back(new ProfileImportHandler());
 299 #endif  // OS_ANDROID
 300
 301 #if defined(ENABLE_MDNS)
 302   if (CommandLine::ForCurrentProcess()->HasSwitch(
 303           switches::kUtilityProcessEnableMDns)) {
 304     handlers_.push_back(new local_discovery::ServiceDiscoveryMessageHandler());
 305   }
 306 #endif  // ENABLE_MDNS
 307 }
 308
 309 ChromeContentUtilityClient::~ChromeContentUtilityClient() {
 310 }
 311
 312 void ChromeContentUtilityClient::UtilityThreadStarted() {
 313   CommandLine* command_line = CommandLine::ForCurrentProcess();
 314   std::string lang = command_line->GetSwitchValueASCII(switches::kLang);
 315   if (!lang.empty())
 316     extension_l10n_util::SetProcessLocale(lang);
 317 }
 318
 319 bool ChromeContentUtilityClient::OnMessageReceived(
 320     const IPC::Message& message) {
 321   bool handled = true;
 322   IPC_BEGIN_MESSAGE_MAP(ChromeContentUtilityClient, message)
 323     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackExtension, OnUnpackExtension)
 324     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackWebResource,
 325                         OnUnpackWebResource)
 326     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseUpdateManifest,
 327                         OnParseUpdateManifest)
 328     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImage, OnDecodeImage)
 329     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImageBase64, OnDecodeImageBase64)
 330     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafile,
 331                         OnRenderPDFPagesToMetafile)
 332     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToPWGRaster,
 333                         OnRenderPDFPagesToPWGRaster)
 334     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RobustJPEGDecodeImage,
 335                         OnRobustJPEGDecodeImage)
 336     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseJSON, OnParseJSON)
 337     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_GetPrinterCapsAndDefaults,
 338                         OnGetPrinterCapsAndDefaults)
 339     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_StartupPing, OnStartupPing)
 340     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_AnalyzeZipFileForDownloadProtection,
 341                         OnAnalyzeZipFileForDownloadProtection)
 342
 343 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 344     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_CheckMediaFile, OnCheckMediaFile)
 345 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 346
 347 #if defined(OS_CHROMEOS)
 348     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_CreateZipFile, OnCreateZipFile)
 349 #endif  // defined(OS_CHROMEOS)
 350
 351 #if defined(OS_WIN)
 352     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseITunesPrefXml,
 353                         OnParseITunesPrefXml)
 354 #endif  // defined(OS_WIN)
 355
 356 #if defined(OS_MACOSX)
 357     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseIPhotoLibraryXmlFile,
 358                         OnParseIPhotoLibraryXmlFile)
 359 #endif  // defined(OS_MACOSX)
 360
 361 #if defined(OS_WIN) || defined(OS_MACOSX)
 362     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseITunesLibraryXmlFile,
 363                         OnParseITunesLibraryXmlFile)
 364     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParsePicasaPMPDatabase,
 365                         OnParsePicasaPMPDatabase)
 366     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_IndexPicasaAlbumsContents,
 367                         OnIndexPicasaAlbumsContents)
 368 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 369
 370     IPC_MESSAGE_UNHANDLED(handled = false)
 371   IPC_END_MESSAGE_MAP()
 372
 373   for (Handlers::iterator it = handlers_.begin();
 374        !handled && it != handlers_.end(); ++it) {
 375     handled = (*it)->OnMessageReceived(message);
 376   }
 377
 378   return handled;
 379 }
 380
 381 // static
 382 void ChromeContentUtilityClient::PreSandboxStartup() {
 383 #if defined(ENABLE_MDNS)
 384   local_discovery::ServiceDiscoveryMessageHandler::PreSandboxStartup();
 385 #endif  // ENABLE_MDNS
 386
 387   g_pdf_lib.Get().Init();
 388
 389   // Load media libraries for media file validation.
 390   base::FilePath media_path;
 391   PathService::Get(content::DIR_MEDIA_LIBS, &media_path);
 392   if (!media_path.empty())
 393     media::InitializeMediaLibrary(media_path);
 394 }
 395
 396 void ChromeContentUtilityClient::OnUnpackExtension(
 397     const base::FilePath& extension_path,
 398     const std::string& extension_id,
 399     int location,
 400     int creation_flags) {
 401   CHECK_GT(location, extensions::Manifest::INVALID_LOCATION);
 402   CHECK_LT(location, extensions::Manifest::NUM_LOCATIONS);
 403   extensions::ExtensionsClient::Set(
 404       extensions::ChromeExtensionsClient::GetInstance());
 405   extensions::Unpacker unpacker(
 406       extension_path,
 407       extension_id,
 408       static_cast<extensions::Manifest::Location>(location),
 409       creation_flags);
 410   if (unpacker.Run() && unpacker.DumpImagesToFile() &&
 411       unpacker.DumpMessageCatalogsToFile()) {
 412     Send(new ChromeUtilityHostMsg_UnpackExtension_Succeeded(
 413         *unpacker.parsed_manifest()));
 414   } else {
 415     Send(new ChromeUtilityHostMsg_UnpackExtension_Failed(
 416         unpacker.error_message()));
 417   }
 418
 419   ReleaseProcessIfNeeded();
 420 }
 421
 422 void ChromeContentUtilityClient::OnUnpackWebResource(
 423     const std::string& resource_data) {
 424   // Parse json data.
 425   // TODO(mrc): Add the possibility of a template that controls parsing, and
 426   // the ability to download and verify images.
 427   WebResourceUnpacker unpacker(resource_data);
 428   if (unpacker.Run()) {
 429     Send(new ChromeUtilityHostMsg_UnpackWebResource_Succeeded(
 430         *unpacker.parsed_json()));
 431   } else {
 432     Send(new ChromeUtilityHostMsg_UnpackWebResource_Failed(
 433         unpacker.error_message()));
 434   }
 435
 436   ReleaseProcessIfNeeded();
 437 }
 438
 439 void ChromeContentUtilityClient::OnParseUpdateManifest(const std::string& xml) {
 440   UpdateManifest manifest;
 441   if (!manifest.Parse(xml)) {
 442     Send(new ChromeUtilityHostMsg_ParseUpdateManifest_Failed(
 443         manifest.errors()));
 444   } else {
 445     Send(new ChromeUtilityHostMsg_ParseUpdateManifest_Succeeded(
 446         manifest.results()));
 447   }
 448   ReleaseProcessIfNeeded();
 449 }
 450
 451 void ChromeContentUtilityClient::OnDecodeImage(
 452     const std::vector<unsigned char>& encoded_data) {
 453   const SkBitmap& decoded_image = content::DecodeImage(&encoded_data[0],
 454                                                        gfx::Size(),
 455                                                        encoded_data.size());
 456   if (decoded_image.empty()) {
 457     Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
 458   } else {
 459     Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(decoded_image));
 460   }
 461   ReleaseProcessIfNeeded();
 462 }
 463
 464 void ChromeContentUtilityClient::OnDecodeImageBase64(
 465     const std::string& encoded_string) {
 466   std::string decoded_string;
 467
 468   if (!base::Base64Decode(encoded_string, &decoded_string)) {
 469     Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
 470     return;
 471   }
 472
 473   std::vector<unsigned char> decoded_vector(decoded_string.size());
 474   for (size_t i = 0; i < decoded_string.size(); ++i) {
 475     decoded_vector[i] = static_cast<unsigned char>(decoded_string[i]);
 476   }
 477
 478   OnDecodeImage(decoded_vector);
 479 }
 480
 481 #if defined(OS_CHROMEOS)
 482 void ChromeContentUtilityClient::OnCreateZipFile(
 483     const base::FilePath& src_dir,
 484     const std::vector<base::FilePath>& src_relative_paths,
 485     const base::FileDescriptor& dest_fd) {
 486   bool succeeded = true;
 487
 488   // Check sanity of source relative paths. Reject if path is absolute or
 489   // contains any attempt to reference a parent directory ("../" tricks).
 490   for (std::vector<base::FilePath>::const_iterator iter =
 491            src_relative_paths.begin(); iter != src_relative_paths.end();
 492        ++iter) {
 493     if (iter->IsAbsolute() || iter->ReferencesParent()) {
 494       succeeded = false;
 495       break;
 496     }
 497   }
 498
 499   if (succeeded)
 500     succeeded = zip::ZipFiles(src_dir, src_relative_paths, dest_fd.fd);
 501
 502   if (succeeded)
 503     Send(new ChromeUtilityHostMsg_CreateZipFile_Succeeded());
 504   else
 505     Send(new ChromeUtilityHostMsg_CreateZipFile_Failed());
 506   ReleaseProcessIfNeeded();
 507 }
 508 #endif  // defined(OS_CHROMEOS)
 509
 510 void ChromeContentUtilityClient::OnRenderPDFPagesToMetafile(
 511     base::PlatformFile pdf_file,
 512     const base::FilePath& metafile_path,
 513     const printing::PdfRenderSettings& settings,
 514     const std::vector<printing::PageRange>& page_ranges) {
 515   bool succeeded = false;
 516 #if defined(OS_WIN)
 517   int highest_rendered_page_number = 0;
 518   double scale_factor = 1.0;
 519   succeeded = RenderPDFToWinMetafile(pdf_file,
 520                                      metafile_path,
 521                                      settings,
 522                                      page_ranges,
 523                                      &highest_rendered_page_number,
 524                                      &scale_factor);
 525   if (succeeded) {
 526     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
 527         highest_rendered_page_number, scale_factor));
 528   }
 529 #endif  // defined(OS_WIN)
 530   if (!succeeded) {
 531     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
 532   }
 533   ReleaseProcessIfNeeded();
 534 }
 535
 536 void ChromeContentUtilityClient::OnRenderPDFPagesToPWGRaster(
 537     IPC::PlatformFileForTransit pdf_transit,
 538     const printing::PdfRenderSettings& settings,
 539     IPC::PlatformFileForTransit bitmap_transit) {
 540   base::PlatformFile pdf =
 541       IPC::PlatformFileForTransitToPlatformFile(pdf_transit);
 542   base::PlatformFile bitmap =
 543       IPC::PlatformFileForTransitToPlatformFile(bitmap_transit);
 544   if (RenderPDFPagesToPWGRaster(pdf, settings, bitmap)) {
 545     Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Succeeded());
 546   } else {
 547     Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Failed());
 548   }
 549   ReleaseProcessIfNeeded();
 550 }
 551
 552 #if defined(OS_WIN)
 553 bool ChromeContentUtilityClient::RenderPDFToWinMetafile(
 554     base::PlatformFile pdf_file,
 555     const base::FilePath& metafile_path,
 556     const printing::PdfRenderSettings& settings,
 557     const std::vector<printing::PageRange>& page_ranges,
 558     int* highest_rendered_page_number,
 559     double* scale_factor) {
 560   *highest_rendered_page_number = -1;
 561   *scale_factor = 1.0;
 562   base::win::ScopedHandle file(pdf_file);
 563
 564   if (!g_pdf_lib.Get().IsValid())
 565     return false;
 566
 567   // TODO(sanjeevr): Add a method to the PDF DLL that takes in a file handle
 568   // and a page range array. That way we don't need to read the entire PDF into
 569   // memory.
 570   DWORD length = ::GetFileSize(file, NULL);
 571   if (length == INVALID_FILE_SIZE)
 572     return false;
 573
 574   std::vector<uint8> buffer;
 575   buffer.resize(length);
 576   DWORD bytes_read = 0;
 577   if (!ReadFile(pdf_file, &buffer.front(), length, &bytes_read, NULL) ||
 578       (bytes_read != length)) {
 579     return false;
 580   }
 581
 582   int total_page_count = 0;
 583   if (!g_pdf_lib.Get().GetPDFDocInfo(&buffer.front(), buffer.size(),
 584                                      &total_page_count, NULL)) {
 585     return false;
 586   }
 587
 588   printing::Emf metafile;
 589   metafile.InitToFile(metafile_path);
 590   // We need to scale down DC to fit an entire page into DC available area.
 591   // Current metafile is based on screen DC and have current screen size.
 592   // Writing outside of those boundaries will result in the cut-off output.
 593   // On metafiles (this is the case here), scaling down will still record
 594   // original coordinates and we'll be able to print in full resolution.
 595   // Before playback we'll need to counter the scaling up that will happen
 596   // in the service (print_system_win.cc).
 597   *scale_factor = gfx::CalculatePageScale(metafile.context(),
 598                                           settings.area().right(),
 599                                           settings.area().bottom());
 600   gfx::ScaleDC(metafile.context(), *scale_factor);
 601
 602   bool ret = false;
 603   std::vector<printing::PageRange>::const_iterator iter;
 604   for (iter = page_ranges.begin(); iter != page_ranges.end(); ++iter) {
 605     for (int page_number = iter->from; page_number <= iter->to; ++page_number) {
 606       if (page_number >= total_page_count)
 607         break;
 608       // The underlying metafile is of type Emf and ignores the arguments passed
 609       // to StartPage.
 610       metafile.StartPage(gfx::Size(), gfx::Rect(), 1);
 611       if (g_pdf_lib.Get().RenderPDFPageToDC(
 612               &buffer.front(), buffer.size(), page_number, metafile.context(),
 613               settings.dpi(), settings.dpi(), settings.area().x(),
 614               settings.area().y(), settings.area().width(),
 615               settings.area().height(), true, false, true, true,
 616               settings.autorotate())) {
 617         if (*highest_rendered_page_number < page_number)
 618           *highest_rendered_page_number = page_number;
 619         ret = true;
 620       }
 621       metafile.FinishPage();
 622     }
 623   }
 624   metafile.FinishDocument();
 625   return ret;
 626 }
 627 #endif  // defined(OS_WIN)
 628
 629 bool ChromeContentUtilityClient::RenderPDFPagesToPWGRaster(
 630     base::PlatformFile pdf_file,
 631     const printing::PdfRenderSettings& settings,
 632     base::PlatformFile bitmap_file) {
 633   bool autoupdate = true;
 634   if (!g_pdf_lib.Get().IsValid())
 635     return false;
 636
 637   base::PlatformFileInfo info;
 638   if (!base::GetPlatformFileInfo(pdf_file, &info) || info.size <= 0)
 639     return false;
 640
 641   std::string data(info.size, 0);
 642   int data_size = base::ReadPlatformFile(pdf_file, 0, &data[0], data.size());
 643   if (data_size != static_cast<int>(data.size()))
 644     return false;
 645
 646   int total_page_count = 0;
 647   if (!g_pdf_lib.Get().GetPDFDocInfo(data.data(), data.size(),
 648                                      &total_page_count, NULL)) {
 649     return false;
 650   }
 651
 652   cloud_print::PwgEncoder encoder;
 653   std::string pwg_header;
 654   encoder.EncodeDocumentHeader(&pwg_header);
 655   int bytes_written = base::WritePlatformFileAtCurrentPos(bitmap_file,
 656                                                           pwg_header.data(),
 657                                                           pwg_header.size());
 658   if (bytes_written != static_cast<int>(pwg_header.size()))
 659     return false;
 660
 661   cloud_print::BitmapImage image(settings.area().size(),
 662                                  cloud_print::BitmapImage::BGRA);
 663   for (int i = 0; i < total_page_count; ++i) {
 664     if (!g_pdf_lib.Get().RenderPDFPageToBitmap(
 665              data.data(), data.size(), i, image.pixel_data(),
 666              image.size().width(), image.size().height(), settings.dpi(),
 667              settings.dpi(), autoupdate)) {
 668       return false;
 669     }
 670     std::string pwg_page;
 671     if (!encoder.EncodePage(image, settings.dpi(), total_page_count, &pwg_page))
 672       return false;
 673     bytes_written = base::WritePlatformFileAtCurrentPos(bitmap_file,
 674                                                         pwg_page.data(),
 675                                                         pwg_page.size());
 676     if (bytes_written != static_cast<int>(pwg_page.size()))
 677       return false;
 678   }
 679   return true;
 680 }
 681
 682 void ChromeContentUtilityClient::OnRobustJPEGDecodeImage(
 683     const std::vector<unsigned char>& encoded_data) {
 684   // Our robust jpeg decoding is using IJG libjpeg.
 685   if (gfx::JPEGCodec::JpegLibraryVariant() == gfx::JPEGCodec::IJG_LIBJPEG) {
 686     scoped_ptr<SkBitmap> decoded_image(gfx::JPEGCodec::Decode(
 687         &encoded_data[0], encoded_data.size()));
 688     if (!decoded_image.get() || decoded_image->empty()) {
 689       Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
 690     } else {
 691       Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(*decoded_image));
 692     }
 693   } else {
 694     Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
 695   }
 696   ReleaseProcessIfNeeded();
 697 }
 698
 699 void ChromeContentUtilityClient::OnParseJSON(const std::string& json) {
 700   int error_code;
 701   std::string error;
 702   base::Value* value = base::JSONReader::ReadAndReturnError(
 703       json, base::JSON_PARSE_RFC, &error_code, &error);
 704   if (value) {
 705     base::ListValue wrapper;
 706     wrapper.Append(value);
 707     Send(new ChromeUtilityHostMsg_ParseJSON_Succeeded(wrapper));
 708   } else {
 709     Send(new ChromeUtilityHostMsg_ParseJSON_Failed(error));
 710   }
 711   ReleaseProcessIfNeeded();
 712 }
 713
 714 void ChromeContentUtilityClient::OnGetPrinterCapsAndDefaults(
 715     const std::string& printer_name) {
 716 #if defined(ENABLE_FULL_PRINTING)
 717   scoped_refptr<printing::PrintBackend> print_backend =
 718       printing::PrintBackend::CreateInstance(NULL);
 719   printing::PrinterCapsAndDefaults printer_info;
 720
 721   crash_keys::ScopedPrinterInfo crash_key(
 722       print_backend->GetPrinterDriverInfo(printer_name));
 723
 724   if (print_backend->GetPrinterCapsAndDefaults(printer_name, &printer_info)) {
 725     Send(new ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded(
 726         printer_name, printer_info));
 727   } else  // NOLINT
 728 #endif
 729   {
 730     Send(new ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Failed(
 731         printer_name));
 732   }
 733   ReleaseProcessIfNeeded();
 734 }
 735
 736 void ChromeContentUtilityClient::OnStartupPing() {
 737   Send(new ChromeUtilityHostMsg_ProcessStarted);
 738   // Don't release the process, we assume further messages are on the way.
 739 }
 740
 741 void ChromeContentUtilityClient::OnAnalyzeZipFileForDownloadProtection(
 742     const IPC::PlatformFileForTransit& zip_file) {
 743   safe_browsing::zip_analyzer::Results results;
 744   safe_browsing::zip_analyzer::AnalyzeZipFile(
 745       IPC::PlatformFileForTransitToPlatformFile(zip_file), &results);
 746   Send(new ChromeUtilityHostMsg_AnalyzeZipFileForDownloadProtection_Finished(
 747       results));
 748   ReleaseProcessIfNeeded();
 749 }
 750
 751 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 752 void ChromeContentUtilityClient::OnCheckMediaFile(
 753     int64 milliseconds_of_decoding,
 754     const IPC::PlatformFileForTransit& media_file) {
 755   media::MediaFileChecker
 756       checker(IPC::PlatformFileForTransitToPlatformFile(media_file));
 757   const bool check_success = checker.Start(
 758       base::TimeDelta::FromMilliseconds(milliseconds_of_decoding));
 759   Send(new ChromeUtilityHostMsg_CheckMediaFile_Finished(check_success));
 760   ReleaseProcessIfNeeded();
 761 }
 762 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 763
 764 #if defined(OS_WIN)
 765 void ChromeContentUtilityClient::OnParseITunesPrefXml(
 766     const std::string& itunes_xml_data) {
 767   base::FilePath library_path(
 768       itunes::FindLibraryLocationInPrefXml(itunes_xml_data));
 769   Send(new ChromeUtilityHostMsg_GotITunesDirectory(library_path));
 770   ReleaseProcessIfNeeded();
 771 }
 772 #endif  // defined(OS_WIN)
 773
 774 #if defined(OS_MACOSX)
 775 void ChromeContentUtilityClient::OnParseIPhotoLibraryXmlFile(
 776     const IPC::PlatformFileForTransit& iphoto_library_file) {
 777   iphoto::IPhotoLibraryParser parser;
 778   base::PlatformFile file =
 779       IPC::PlatformFileForTransitToPlatformFile(iphoto_library_file);
 780   bool result = parser.Parse(iapps::ReadPlatformFileAsString(file));
 781   Send(new ChromeUtilityHostMsg_GotIPhotoLibrary(result, parser.library()));
 782   ReleaseProcessIfNeeded();
 783 }
 784 #endif  // defined(OS_MACOSX)
 785
 786 #if defined(OS_WIN) || defined(OS_MACOSX)
 787 void ChromeContentUtilityClient::OnParseITunesLibraryXmlFile(
 788     const IPC::PlatformFileForTransit& itunes_library_file) {
 789   itunes::ITunesLibraryParser parser;
 790   base::PlatformFile file =
 791       IPC::PlatformFileForTransitToPlatformFile(itunes_library_file);
 792   bool result = parser.Parse(iapps::ReadPlatformFileAsString(file));
 793   Send(new ChromeUtilityHostMsg_GotITunesLibrary(result, parser.library()));
 794   ReleaseProcessIfNeeded();
 795 }
 796
 797 void ChromeContentUtilityClient::OnParsePicasaPMPDatabase(
 798     const picasa::AlbumTableFilesForTransit& album_table_files) {
 799   picasa::AlbumTableFiles files;
 800   files.indicator_file = IPC::PlatformFileForTransitToPlatformFile(
 801       album_table_files.indicator_file);
 802   files.category_file = IPC::PlatformFileForTransitToPlatformFile(
 803       album_table_files.category_file);
 804   files.date_file = IPC::PlatformFileForTransitToPlatformFile(
 805       album_table_files.date_file);
 806   files.filename_file = IPC::PlatformFileForTransitToPlatformFile(
 807       album_table_files.filename_file);
 808   files.name_file = IPC::PlatformFileForTransitToPlatformFile(
 809       album_table_files.name_file);
 810   files.token_file = IPC::PlatformFileForTransitToPlatformFile(
 811       album_table_files.token_file);
 812   files.uid_file = IPC::PlatformFileForTransitToPlatformFile(
 813       album_table_files.uid_file);
 814
 815   picasa::PicasaAlbumTableReader reader(files);
 816   bool parse_success = reader.Init();
 817   Send(new ChromeUtilityHostMsg_ParsePicasaPMPDatabase_Finished(
 818       parse_success,
 819       reader.albums(),
 820       reader.folders()));
 821   ReleaseProcessIfNeeded();
 822 }
 823
 824 void ChromeContentUtilityClient::OnIndexPicasaAlbumsContents(
 825     const picasa::AlbumUIDSet& album_uids,
 826     const std::vector<picasa::FolderINIContents>& folders_inis) {
 827   picasa::PicasaAlbumsIndexer indexer(album_uids);
 828   indexer.ParseFolderINI(folders_inis);
 829
 830   Send(new ChromeUtilityHostMsg_IndexPicasaAlbumsContents_Finished(
 831       indexer.albums_images()));
 832   ReleaseProcessIfNeeded();
 833 }
 834 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 835
 836 }  // namespace chrome