Initial support for partitioning cookies for isolated apps.

chrome/common/extensions/extension.cc

 // Copyright (c) 2010 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 <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/base64.h"
@@ skipping 991 matching lines @@
     if (!temp->GetAsInteger(&launch_height_) || launch_height_ < 0) {
       launch_height_ = 0;
       *error = errors::kInvalidLaunchHeight;
       return false;
     }
   }
 
   return true;
 }
 
+bool Extension::LoadAppIsolation(const DictionaryValue* manifest,
+                                 std::string* error) {
+  // Only parse app isolation features if this switch is present.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableExperimentalAppManifests))
+    return true;
+
+  Value* temp = NULL;
+  if (!manifest->Get(keys::kIsolation, &temp))
+    return true;
+
+  if (temp->GetType() != Value::TYPE_LIST) {
+    *error = errors::kInvalidIsolation;
+    return false;
+  }
+
+  ListValue* isolation_list = static_cast<ListValue*>(temp);
+  for (size_t i = 0; i < isolation_list->GetSize(); ++i) {
+    std::string isolation_string;
+    if (!isolation_list->GetString(i, &isolation_string)) {
+      *error = ExtensionErrorUtils::FormatErrorMessage(
+          errors::kInvalidIsolationValue,
+          base::UintToString(i));
+      return false;
+    }
+
+    // Check for isolated storage.
+    if (isolation_string == keys::kIsolatedStorage)
+      is_storage_isolated_ = true;
+  }
+  return true;
+}
+
 bool Extension::EnsureNotHybridApp(const DictionaryValue* manifest,
                                    std::string* error) {
   if (web_extent().is_empty())
     return true;
 
   for (DictionaryValue::key_iterator key = manifest->begin_keys();
        key != manifest->end_keys(); ++key) {
     if (!IsBaseCrxKey(*key) &&
         *key != keys::kApp &&
         *key != keys::kPermissions &&
         *key != keys::kOptionsPage) {
       *error = errors::kHostedAppsCannotIncludeExtensionFeatures;
       return false;
     }
   }
 
   return true;
 }
 
 Extension::Extension(const FilePath& path, Location location)
     : incognito_split_mode_(false),
       location_(location),
       converted_from_user_script_(false),
       is_theme_(false),
       is_app_(false),
+      is_storage_isolated_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0) {
   DCHECK(path.IsAbsolute());
   path_ = MaybeNormalizePath(path);
 }
 Extension::~Extension() {
 }
 ExtensionResource Extension::GetResource(
     const std::string& relative_path) const {
@@ skipping 617 matching lines @@
       return false;  // Failed to parse browser action definition.
   }
 
   // Load App settings.
   if (!LoadIsApp(manifest_value_.get(), error) ||
       !LoadExtent(manifest_value_.get(), keys::kWebURLs,
                   &extent_,
                   errors::kInvalidWebURLs, errors::kInvalidWebURL, error) ||
       !EnsureNotHybridApp(manifest_value_.get(), error) ||
       !LoadLaunchURL(manifest_value_.get(), error) ||
-      !LoadLaunchContainer(manifest_value_.get(), error)) {
+      !LoadLaunchContainer(manifest_value_.get(), error) ||
+      !LoadAppIsolation(manifest_value_.get(), error)) {
     return false;
   }
 
   // Initialize options page url (optional).
   // Funtion LoadIsApp() set is_app_ above.
   if (source.HasKey(keys::kOptionsPage)) {
     std::string options_str;
     if (!source.GetString(keys::kOptionsPage, &options_str)) {
       *error = errors::kInvalidOptionsPage;
       return false;
@@ skipping 626 matching lines @@
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}
 
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     Reason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}