src/chrome/utility/extensions/extensions_handler.cc

   1 // Copyright 2014 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/extensions/extensions_handler.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/path_service.h"
   9 #include "chrome/common/chrome_utility_messages.h"
  10 #include "chrome/common/extensions/chrome_extensions_client.h"
  11 #include "chrome/common/extensions/chrome_utility_extensions_messages.h"
  12 #include "chrome/common/media_galleries/metadata_types.h"
  13 #include "chrome/utility/chrome_content_utility_client.h"
  14 #include "chrome/utility/extensions/unpacker.h"
  15 #include "chrome/utility/media_galleries/image_metadata_extractor.h"
  16 #include "content/public/common/content_paths.h"
  17 #include "content/public/utility/utility_thread.h"
  18 #include "extensions/common/extension.h"
  19 #include "extensions/common/extension_l10n_util.h"
  20 #include "extensions/common/extension_utility_messages.h"
  21 #include "extensions/common/manifest.h"
  22 #include "media/base/media.h"
  23 #include "media/base/media_file_checker.h"
  24 #include "third_party/zlib/google/zip.h"
  25 #include "ui/base/ui_base_switches.h"
  26
  27 #if defined(OS_WIN)
  28 #include "chrome/common/extensions/api/networking_private/networking_private_crypto.h"
  29 #include "chrome/utility/media_galleries/itunes_pref_parser_win.h"
  30 #include "components/wifi/wifi_service.h"
  31 #endif  // defined(OS_WIN)
  32
  33 #if defined(OS_MACOSX)
  34 #include "chrome/utility/media_galleries/iphoto_library_parser.h"
  35 #endif  // defined(OS_MACOSX)
  36
  37 #if defined(OS_WIN) || defined(OS_MACOSX)
  38 #include "chrome/utility/media_galleries/iapps_xml_utils.h"
  39 #include "chrome/utility/media_galleries/itunes_library_parser.h"
  40 #include "chrome/utility/media_galleries/picasa_album_table_reader.h"
  41 #include "chrome/utility/media_galleries/picasa_albums_indexer.h"
  42 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
  43
  44 namespace extensions {
  45
  46 namespace {
  47
  48 bool Send(IPC::Message* message) {
  49   return content::UtilityThread::Get()->Send(message);
  50 }
  51
  52 void ReleaseProcessIfNeeded() {
  53   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
  54 }
  55
  56 const char kExtensionHandlerUnzipError[] =
  57     "Could not unzip extension for install.";
  58
  59 }  // namespace
  60
  61 ExtensionsHandler::ExtensionsHandler() {
  62 }
  63
  64 ExtensionsHandler::~ExtensionsHandler() {
  65 }
  66
  67 // static
  68 void ExtensionsHandler::PreSandboxStartup() {
  69   // Initialize libexif for image metadata parsing.
  70   metadata::ImageMetadataExtractor::InitializeLibrary();
  71
  72   // Load media libraries for media file validation.
  73   base::FilePath media_path;
  74   PathService::Get(content::DIR_MEDIA_LIBS, &media_path);
  75   if (!media_path.empty())
  76     media::InitializeMediaLibrary(media_path);
  77 }
  78
  79 // static
  80 void ExtensionsHandler::UtilityThreadStarted() {
  81   UtilityHandler::UtilityThreadStarted();
  82 }
  83
  84 bool ExtensionsHandler::OnMessageReceived(const IPC::Message& message) {
  85   bool handled = true;
  86   IPC_BEGIN_MESSAGE_MAP(ExtensionsHandler, message)
  87     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackExtension, OnUnpackExtension)
  88     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnzipToDir, OnUnzipToDir)
  89     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImageBase64, OnDecodeImageBase64)
  90     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseJSON, OnParseJSON)
  91     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_CheckMediaFile, OnCheckMediaFile)
  92 #if defined(OS_WIN)
  93     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseITunesPrefXml,
  94                         OnParseITunesPrefXml)
  95 #endif  // defined(OS_WIN)
  96
  97 #if defined(OS_MACOSX)
  98     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseIPhotoLibraryXmlFile,
  99                         OnParseIPhotoLibraryXmlFile)
 100 #endif  // defined(OS_MACOSX)
 101
 102 #if defined(OS_WIN) || defined(OS_MACOSX)
 103     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseITunesLibraryXmlFile,
 104                         OnParseITunesLibraryXmlFile)
 105     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParsePicasaPMPDatabase,
 106                         OnParsePicasaPMPDatabase)
 107     IPC_MESSAGE_HANDLER(ChromeUtilityMsg_IndexPicasaAlbumsContents,
 108                         OnIndexPicasaAlbumsContents)
 109 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 110
 111 #if defined(OS_WIN)
 112     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_GetWiFiCredentials,
 113                         OnGetWiFiCredentials)
 114 #endif  // defined(OS_WIN)
 115
 116     IPC_MESSAGE_UNHANDLED(handled = false)
 117   IPC_END_MESSAGE_MAP()
 118   return handled || utility_handler_.OnMessageReceived(message);
 119 }
 120
 121 void ExtensionsHandler::OnUnpackExtension(
 122     const base::FilePath& extension_path,
 123     const std::string& extension_id,
 124     int location,
 125     int creation_flags) {
 126   CHECK_GT(location, Manifest::INVALID_LOCATION);
 127   CHECK_LT(location, Manifest::NUM_LOCATIONS);
 128   ExtensionsClient::Set(ChromeExtensionsClient::GetInstance());
 129   Unpacker unpacker(extension_path,
 130                     extension_id,
 131                     static_cast<Manifest::Location>(location),
 132                     creation_flags);
 133   if (unpacker.Run() && unpacker.DumpImagesToFile() &&
 134       unpacker.DumpMessageCatalogsToFile()) {
 135     Send(new ChromeUtilityHostMsg_UnpackExtension_Succeeded(
 136         *unpacker.parsed_manifest()));
 137   } else {
 138     Send(new ChromeUtilityHostMsg_UnpackExtension_Failed(
 139         unpacker.error_message()));
 140   }
 141
 142   ReleaseProcessIfNeeded();
 143 }
 144
 145 void ExtensionsHandler::OnUnzipToDir(const base::FilePath& zip_path,
 146                                      const base::FilePath& dir) {
 147   if (!zip::Unzip(zip_path, dir)) {
 148     Send(new ChromeUtilityHostMsg_UnzipToDir_Failed(
 149         std::string(kExtensionHandlerUnzipError)));
 150   } else {
 151     Send(new ChromeUtilityHostMsg_UnzipToDir_Succeeded(dir));
 152   }
 153
 154   ReleaseProcessIfNeeded();
 155 }
 156
 157 void ExtensionsHandler::OnDecodeImageBase64(
 158     const std::string& encoded_string) {
 159   std::string decoded_string;
 160
 161   if (!base::Base64Decode(encoded_string, &decoded_string)) {
 162     Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
 163     return;
 164   }
 165
 166   std::vector<unsigned char> decoded_vector(decoded_string.size());
 167   for (size_t i = 0; i < decoded_string.size(); ++i) {
 168     decoded_vector[i] = static_cast<unsigned char>(decoded_string[i]);
 169   }
 170
 171   ChromeContentUtilityClient::DecodeImageAndSend(decoded_vector, false);
 172 }
 173
 174 void ExtensionsHandler::OnParseJSON(const std::string& json) {
 175   int error_code;
 176   std::string error;
 177   base::Value* value = base::JSONReader::ReadAndReturnError(
 178       json, base::JSON_PARSE_RFC, &error_code, &error);
 179   if (value) {
 180     base::ListValue wrapper;
 181     wrapper.Append(value);
 182     Send(new ChromeUtilityHostMsg_ParseJSON_Succeeded(wrapper));
 183   } else {
 184     Send(new ChromeUtilityHostMsg_ParseJSON_Failed(error));
 185   }
 186   ReleaseProcessIfNeeded();
 187 }
 188
 189 void ExtensionsHandler::OnCheckMediaFile(
 190     int64 milliseconds_of_decoding,
 191     const IPC::PlatformFileForTransit& media_file) {
 192   media::MediaFileChecker checker(
 193       IPC::PlatformFileForTransitToFile(media_file));
 194   const bool check_success = checker.Start(
 195       base::TimeDelta::FromMilliseconds(milliseconds_of_decoding));
 196   Send(new ChromeUtilityHostMsg_CheckMediaFile_Finished(check_success));
 197   ReleaseProcessIfNeeded();
 198 }
 199
 200 #if defined(OS_WIN)
 201 void ExtensionsHandler::OnParseITunesPrefXml(
 202     const std::string& itunes_xml_data) {
 203   base::FilePath library_path(
 204       itunes::FindLibraryLocationInPrefXml(itunes_xml_data));
 205   Send(new ChromeUtilityHostMsg_GotITunesDirectory(library_path));
 206   ReleaseProcessIfNeeded();
 207 }
 208 #endif  // defined(OS_WIN)
 209
 210 #if defined(OS_MACOSX)
 211 void ExtensionsHandler::OnParseIPhotoLibraryXmlFile(
 212     const IPC::PlatformFileForTransit& iphoto_library_file) {
 213   iphoto::IPhotoLibraryParser parser;
 214   base::File file = IPC::PlatformFileForTransitToFile(iphoto_library_file);
 215   bool result = parser.Parse(iapps::ReadFileAsString(file.Pass()));
 216   Send(new ChromeUtilityHostMsg_GotIPhotoLibrary(result, parser.library()));
 217   ReleaseProcessIfNeeded();
 218 }
 219 #endif  // defined(OS_MACOSX)
 220
 221 #if defined(OS_WIN) || defined(OS_MACOSX)
 222 void ExtensionsHandler::OnParseITunesLibraryXmlFile(
 223     const IPC::PlatformFileForTransit& itunes_library_file) {
 224   itunes::ITunesLibraryParser parser;
 225   base::File file = IPC::PlatformFileForTransitToFile(itunes_library_file);
 226   bool result = parser.Parse(iapps::ReadFileAsString(file.Pass()));
 227   Send(new ChromeUtilityHostMsg_GotITunesLibrary(result, parser.library()));
 228   ReleaseProcessIfNeeded();
 229 }
 230
 231 void ExtensionsHandler::OnParsePicasaPMPDatabase(
 232     const picasa::AlbumTableFilesForTransit& album_table_files) {
 233   picasa::AlbumTableFiles files;
 234   files.indicator_file =
 235       IPC::PlatformFileForTransitToFile(album_table_files.indicator_file);
 236   files.category_file =
 237       IPC::PlatformFileForTransitToFile(album_table_files.category_file);
 238   files.date_file =
 239       IPC::PlatformFileForTransitToFile(album_table_files.date_file);
 240   files.filename_file =
 241       IPC::PlatformFileForTransitToFile(album_table_files.filename_file);
 242   files.name_file =
 243       IPC::PlatformFileForTransitToFile(album_table_files.name_file);
 244   files.token_file =
 245       IPC::PlatformFileForTransitToFile(album_table_files.token_file);
 246   files.uid_file =
 247       IPC::PlatformFileForTransitToFile(album_table_files.uid_file);
 248
 249   picasa::PicasaAlbumTableReader reader(files.Pass());
 250   bool parse_success = reader.Init();
 251   Send(new ChromeUtilityHostMsg_ParsePicasaPMPDatabase_Finished(
 252       parse_success, reader.albums(), reader.folders()));
 253   ReleaseProcessIfNeeded();
 254 }
 255
 256 void ExtensionsHandler::OnIndexPicasaAlbumsContents(
 257     const picasa::AlbumUIDSet& album_uids,
 258     const std::vector<picasa::FolderINIContents>& folders_inis) {
 259   picasa::PicasaAlbumsIndexer indexer(album_uids);
 260   indexer.ParseFolderINI(folders_inis);
 261
 262   Send(new ChromeUtilityHostMsg_IndexPicasaAlbumsContents_Finished(
 263       indexer.albums_images()));
 264   ReleaseProcessIfNeeded();
 265 }
 266 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 267
 268 #if defined(OS_WIN)
 269 void ExtensionsHandler::OnGetWiFiCredentials(const std::string& network_guid) {
 270   scoped_ptr<wifi::WiFiService> wifi_service(wifi::WiFiService::Create());
 271   wifi_service->Initialize(NULL);
 272
 273   std::string key_data;
 274   std::string error;
 275   wifi_service->GetKeyFromSystem(network_guid, &key_data, &error);
 276
 277   Send(new ChromeUtilityHostMsg_GotWiFiCredentials(key_data, error.empty()));
 278 }
 279 #endif  // defined(OS_WIN)
 280
 281 }  // namespace extensions