Rename PACKAGED_APP references to LEGACY_PACKAGED_APP

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 480 matching lines @@
 }
 
 bool Extension::is_platform_app() const {
   return manifest_->is_platform_app();
 }
 
 bool Extension::is_hosted_app() const {
   return manifest()->is_hosted_app();
 }
 
-bool Extension::is_packaged_app() const {
-  return manifest()->is_packaged_app();
+bool Extension::is_legacy_packaged_app() const {
+  return manifest()->is_legacy_packaged_app();
 }
 
 bool Extension::is_theme() const {
   return manifest()->is_theme();
 }
 
 GURL Extension::GetBackgroundURL() const {
   if (background_scripts_.empty())
     return background_url_;
   return GetResourceURL(extension_filenames::kGeneratedBackgroundPageFilename);
@@ skipping 636 matching lines @@
     GURL url(launch_url);
     URLPattern pattern(kValidWebExtentSchemes);
     if (!url.is_valid() || !pattern.SetScheme(url.scheme())) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchWebURL);
       return false;
     }
 
     launch_web_url_ = launch_url;
-  } else if (is_packaged_app() || is_hosted_app()) {
+  } else if (is_legacy_packaged_app() || is_hosted_app()) {
     *error = ASCIIToUTF16(errors::kLaunchURLRequired);
     return false;
   }
 
   // If there is no extent, we default the extent based on the launch URL.
   if (web_extent().is_empty() && !launch_web_url().empty()) {
     GURL launch_url(launch_web_url());
     URLPattern pattern(kValidWebExtentSchemes);
     if (!pattern.SetScheme("*")) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
@@ skipping 773 matching lines @@
     if (!intent_service.GetString(keys::kIntentHref, &href)) {
       *error = ASCIIToUTF16(errors::kInvalidIntentHref);
       return false;
     }
   }
 
   // For packaged/hosted apps, empty href implies the respective launch URLs.
   if (href.empty()) {
     if (is_hosted_app()) {
       href = launch_web_url();
-    } else if (is_packaged_app()) {
+    } else if (is_legacy_packaged_app()) {
       href = launch_local_path();
     }
   }
 
   // If there still is not an  href, the manifest is malformed, unless this is a
   // platform app in which case the href should not be present.
   if (href.empty() && !is_platform_app()) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidIntentHrefEmpty, action_name);
     return false;
@@ skipping 600 matching lines @@
 #endif
 
     if (is_override || !overrides->GetStringWithoutPathExpansion(*iter, &val)) {
       *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
       return false;
     }
     // Replace the entry with a fully qualified chrome-extension:// URL.
     chrome_url_overrides_[page] = GetResourceURL(val);
 
     // For component extensions, add override URL to extent patterns.
-    if (is_packaged_app() && location() == COMPONENT) {
+    if (is_legacy_packaged_app() && location() == COMPONENT) {
       URLPattern pattern(URLPattern::SCHEME_CHROMEUI);
       std::string url = base::StringPrintf(kOverrideExtentUrlPatternFormat,
                                            page.c_str());
       if (pattern.Parse(url) != URLPattern::PARSE_SUCCESS) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, url);
         return false;
       }
       extent_.AddPattern(pattern);
     }
@@ skipping 1147 matching lines @@
       return SYNC_TYPE_EXTENSION;
 
     case Extension::TYPE_USER_SCRIPT:
       // We only want to sync user scripts with gallery update URLs.
       if (UpdatesFromGallery())
         return SYNC_TYPE_EXTENSION;
       else
         return SYNC_TYPE_NONE;
 
     case Extension::TYPE_HOSTED_APP:
-    case Extension::TYPE_PACKAGED_APP:
+    case Extension::TYPE_LEGACY_PACKAGED_APP:
         return SYNC_TYPE_APP;
 
     default:
       return SYNC_TYPE_NONE;
   }
 }
 
 bool Extension::IsSyncable() const {
   // TODO(akalin): Figure out if we need to allow some other types.
 
@@ skipping 209 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions