chrome/browser/extensions/convert_web_app.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/browser/extensions/convert_web_app.h"
   6
   7 #include <cmath>
   8 #include <limits>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/base64.h"
  13 #include "base/file_util.h"
  14 #include "base/files/file_path.h"
  15 #include "base/files/scoped_temp_dir.h"
  16 #include "base/json/json_file_value_serializer.h"
  17 #include "base/logging.h"
  18 #include "base/numerics/safe_conversions.h"
  19 #include "base/path_service.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/time/time.h"
  23 #include "chrome/common/chrome_paths.h"
  24 #include "chrome/common/extensions/extension_file_util.h"
  25 #include "chrome/common/web_application_info.h"
  26 #include "crypto/sha2.h"
  27 #include "extensions/common/constants.h"
  28 #include "extensions/common/extension.h"
  29 #include "extensions/common/manifest_constants.h"
  30 #include "third_party/skia/include/core/SkBitmap.h"
  31 #include "ui/gfx/codec/png_codec.h"
  32 #include "url/gurl.h"
  33
  34 namespace extensions {
  35
  36 namespace keys = manifest_keys;
  37
  38 using base::Time;
  39
  40 namespace {
  41
  42 const char kIconsDirName[] = "icons";
  43
  44 // Create the public key for the converted web app.
  45 //
  46 // Web apps are not signed, but the public key for an extension doubles as
  47 // its unique identity, and we need one of those. A web app's unique identity
  48 // is its manifest URL, so we hash that to create a public key. There will be
  49 // no corresponding private key, which means that these extensions cannot be
  50 // auto-updated using ExtensionUpdater. But Chrome does notice updates to the
  51 // manifest and regenerates these extensions.
  52 std::string GenerateKey(const GURL& manifest_url) {
  53   char raw[crypto::kSHA256Length] = {0};
  54   std::string key;
  55   crypto::SHA256HashString(manifest_url.spec().c_str(), raw,
  56                            crypto::kSHA256Length);
  57   base::Base64Encode(std::string(raw, crypto::kSHA256Length), &key);
  58   return key;
  59 }
  60
  61 }  // namespace
  62
  63 // Generates a version for the converted app using the current date. This isn't
  64 // really needed, but it seems like useful information.
  65 std::string ConvertTimeToExtensionVersion(const Time& create_time) {
  66   Time::Exploded create_time_exploded;
  67   create_time.UTCExplode(&create_time_exploded);
  68
  69   double micros = static_cast<double>(
  70       (create_time_exploded.millisecond * Time::kMicrosecondsPerMillisecond) +
  71       (create_time_exploded.second * Time::kMicrosecondsPerSecond) +
  72       (create_time_exploded.minute * Time::kMicrosecondsPerMinute) +
  73       (create_time_exploded.hour * Time::kMicrosecondsPerHour));
  74   double day_fraction = micros / Time::kMicrosecondsPerDay;
  75   double stamp = day_fraction * std::numeric_limits<uint16>::max();
  76
  77   // Ghetto-round, since VC++ doesn't have round().
  78   stamp = stamp >= (floor(stamp) + 0.5) ? (stamp + 1) : stamp;
  79
  80   return base::StringPrintf("%i.%i.%i.%i",
  81                             create_time_exploded.year,
  82                             create_time_exploded.month,
  83                             create_time_exploded.day_of_month,
  84                             static_cast<uint16>(stamp));
  85 }
  86
  87 scoped_refptr<Extension> ConvertWebAppToExtension(
  88     const WebApplicationInfo& web_app,
  89     const Time& create_time,
  90     const base::FilePath& extensions_dir) {
  91   base::FilePath install_temp_dir =
  92       extension_file_util::GetInstallTempDir(extensions_dir);
  93   if (install_temp_dir.empty()) {
  94     LOG(ERROR) << "Could not get path to profile temporary directory.";
  95     return NULL;
  96   }
  97
  98   base::ScopedTempDir temp_dir;
  99   if (!temp_dir.CreateUniqueTempDirUnderPath(install_temp_dir)) {
 100     LOG(ERROR) << "Could not create temporary directory.";
 101     return NULL;
 102   }
 103
 104   // Create the manifest
 105   scoped_ptr<base::DictionaryValue> root(new base::DictionaryValue);
 106   if (!web_app.is_bookmark_app)
 107     root->SetString(keys::kPublicKey, GenerateKey(web_app.manifest_url));
 108   else
 109     root->SetString(keys::kPublicKey, GenerateKey(web_app.app_url));
 110
 111   if (web_app.is_offline_enabled)
 112     root->SetBoolean(keys::kOfflineEnabled, true);
 113
 114   root->SetString(keys::kName, base::UTF16ToUTF8(web_app.title));
 115   root->SetString(keys::kVersion, ConvertTimeToExtensionVersion(create_time));
 116   root->SetString(keys::kDescription, base::UTF16ToUTF8(web_app.description));
 117   root->SetString(keys::kLaunchWebURL, web_app.app_url.spec());
 118
 119   if (!web_app.launch_container.empty())
 120     root->SetString(keys::kLaunchContainer, web_app.launch_container);
 121
 122   // Add the icons.
 123   base::DictionaryValue* icons = new base::DictionaryValue();
 124   root->Set(keys::kIcons, icons);
 125   for (size_t i = 0; i < web_app.icons.size(); ++i) {
 126     std::string size = base::StringPrintf("%i", web_app.icons[i].width);
 127     std::string icon_path = base::StringPrintf("%s/%s.png", kIconsDirName,
 128                                                size.c_str());
 129     icons->SetString(size, icon_path);
 130   }
 131
 132   // Add the permissions.
 133   base::ListValue* permissions = new base::ListValue();
 134   root->Set(keys::kPermissions, permissions);
 135   for (size_t i = 0; i < web_app.permissions.size(); ++i) {
 136     permissions->Append(new base::StringValue(web_app.permissions[i]));
 137   }
 138
 139   // Add the URLs.
 140   base::ListValue* urls = new base::ListValue();
 141   root->Set(keys::kWebURLs, urls);
 142   for (size_t i = 0; i < web_app.urls.size(); ++i) {
 143     urls->Append(new base::StringValue(web_app.urls[i].spec()));
 144   }
 145
 146   // Write the manifest.
 147   base::FilePath manifest_path = temp_dir.path().Append(kManifestFilename);
 148   JSONFileValueSerializer serializer(manifest_path);
 149   if (!serializer.Serialize(*root)) {
 150     LOG(ERROR) << "Could not serialize manifest.";
 151     return NULL;
 152   }
 153
 154   // Write the icon files.
 155   base::FilePath icons_dir = temp_dir.path().AppendASCII(kIconsDirName);
 156   if (!base::CreateDirectory(icons_dir)) {
 157     LOG(ERROR) << "Could not create icons directory.";
 158     return NULL;
 159   }
 160   for (size_t i = 0; i < web_app.icons.size(); ++i) {
 161     // Skip unfetched bitmaps.
 162     if (web_app.icons[i].data.config() == SkBitmap::kNo_Config)
 163       continue;
 164
 165     base::FilePath icon_file = icons_dir.AppendASCII(
 166         base::StringPrintf("%i.png", web_app.icons[i].width));
 167     std::vector<unsigned char> image_data;
 168     if (!gfx::PNGCodec::EncodeBGRASkBitmap(web_app.icons[i].data,
 169                                            false,
 170                                            &image_data)) {
 171       LOG(ERROR) << "Could not create icon file.";
 172       return NULL;
 173     }
 174
 175     const char* image_data_ptr = reinterpret_cast<const char*>(&image_data[0]);
 176     int size = base::checked_cast<int>(image_data.size());
 177     if (file_util::WriteFile(icon_file, image_data_ptr, size) != size) {
 178       LOG(ERROR) << "Could not write icon file.";
 179       return NULL;
 180     }
 181   }
 182
 183   // Finally, create the extension object to represent the unpacked directory.
 184   std::string error;
 185   int extension_flags = Extension::NO_FLAGS;
 186   if (web_app.is_bookmark_app)
 187     extension_flags |= Extension::FROM_BOOKMARK;
 188   scoped_refptr<Extension> extension = Extension::Create(
 189       temp_dir.path(),
 190       Manifest::INTERNAL,
 191       *root,
 192       extension_flags,
 193       &error);
 194   if (!extension.get()) {
 195     LOG(ERROR) << error;
 196     return NULL;
 197   }
 198
 199   temp_dir.Take();  // The caller takes ownership of the directory.
 200   return extension;
 201 }
 202
 203 }  // namespace extensions