Remove unused members from WebApplicationInfo.

chrome/browser/extensions/convert_web_app.cc

 // Copyright (c) 2012 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/extensions/convert_web_app.h"
 
 #include <cmath>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 29 matching lines @@
 namespace {
 
 const char kIconsDirName[] = "icons";
 
 // Create the public key for the converted web app.
 //
 // Web apps are not signed, but the public key for an extension doubles as
 // its unique identity, and we need one of those. A web app's unique identity
 // is its manifest URL, so we hash that to create a public key. There will be
 // no corresponding private key, which means that these extensions cannot be
-// auto-updated using ExtensionUpdater. But Chrome does notice updates to the
-// manifest and regenerates these extensions.
-std::string GenerateKey(const GURL& manifest_url) {
+// auto-updated using ExtensionUpdater.
+std::string GenerateKey(const GURL& app_url) {
   char raw[crypto::kSHA256Length] = {0};
   std::string key;
-  crypto::SHA256HashString(manifest_url.spec().c_str(), raw,
+  crypto::SHA256HashString(app_url.spec().c_str(), raw,
                            crypto::kSHA256Length);
   base::Base64Encode(std::string(raw, crypto::kSHA256Length), &key);
   return key;
 }
 
 }  // namespace
 
 // Generates a version for the converted app using the current date. This isn't
 // really needed, but it seems like useful information.
 std::string ConvertTimeToExtensionVersion(const Time& create_time) {
@@ skipping 30 matching lines @@
   }
 
   base::ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDirUnderPath(install_temp_dir)) {
     LOG(ERROR) << "Could not create temporary directory.";
     return NULL;
   }
 
   // Create the manifest
   scoped_ptr<base::DictionaryValue> root(new base::DictionaryValue);
-  if (!web_app.is_bookmark_app)
-    root->SetString(keys::kPublicKey, GenerateKey(web_app.manifest_url));
-  else
-    root->SetString(keys::kPublicKey, GenerateKey(web_app.app_url));
-
-  if (web_app.is_offline_enabled)
-    root->SetBoolean(keys::kOfflineEnabled, true);
-
+  root->SetString(keys::kPublicKey, GenerateKey(web_app.app_url));
   root->SetString(keys::kName, base::UTF16ToUTF8(web_app.title));
   root->SetString(keys::kVersion, ConvertTimeToExtensionVersion(create_time));
   root->SetString(keys::kDescription, base::UTF16ToUTF8(web_app.description));
   root->SetString(keys::kLaunchWebURL, web_app.app_url.spec());
 
-  if (!web_app.launch_container.empty())
-    root->SetString(keys::kLaunchContainer, web_app.launch_container);
-
   // Add the icons.
   base::DictionaryValue* icons = new base::DictionaryValue();
   root->Set(keys::kIcons, icons);
   for (size_t i = 0; i < web_app.icons.size(); ++i) {
     std::string size = base::StringPrintf("%i", web_app.icons[i].width);
     std::string icon_path = base::StringPrintf("%s/%s.png", kIconsDirName,
                                                size.c_str());
     icons->SetString(size, icon_path);
   }
 
-  // Add the permissions.
-  base::ListValue* permissions = new base::ListValue();
-  root->Set(keys::kPermissions, permissions);
-  for (size_t i = 0; i < web_app.permissions.size(); ++i) {
-    permissions->Append(new base::StringValue(web_app.permissions[i]));
-  }
-
-  // Add the URLs.
-  base::ListValue* urls = new base::ListValue();
-  root->Set(keys::kWebURLs, urls);
-  for (size_t i = 0; i < web_app.urls.size(); ++i) {
-    urls->Append(new base::StringValue(web_app.urls[i].spec()));
-  }
-
   // Write the manifest.
   base::FilePath manifest_path = temp_dir.path().Append(kManifestFilename);
   JSONFileValueSerializer serializer(manifest_path);
   if (!serializer.Serialize(*root)) {
     LOG(ERROR) << "Could not serialize manifest.";
     return NULL;
   }
 
   // Write the icon files.
   base::FilePath icons_dir = temp_dir.path().AppendASCII(kIconsDirName);
@@ skipping 19 matching lines @@
     const char* image_data_ptr = reinterpret_cast<const char*>(&image_data[0]);
     int size = base::checked_numeric_cast<int>(image_data.size());
     if (file_util::WriteFile(icon_file, image_data_ptr, size) != size) {
       LOG(ERROR) << "Could not write icon file.";
       return NULL;
     }
   }
 
   // Finally, create the extension object to represent the unpacked directory.
   std::string error;
-  int extension_flags = Extension::NO_FLAGS;
-  if (web_app.is_bookmark_app)
-    extension_flags |= Extension::FROM_BOOKMARK;
   scoped_refptr<Extension> extension = Extension::Create(
       temp_dir.path(),
       Manifest::INTERNAL,
       *root,
-      extension_flags,
+      Extension::FROM_BOOKMARK,
       &error);
   if (!extension.get()) {
     LOG(ERROR) << error;
     return NULL;
   }
 
   temp_dir.Take();  // The caller takes ownership of the directory.
   return extension;
 }
 
 }  // namespace extensions