Enable experimental permissions for extensions from the store.

chrome/browser/extensions/sandboxed_extension_unpacker.cc

 // Copyright (c) 2011 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/sandboxed_extension_unpacker.h"
 
 #include <set>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/file_util_proxy.h"
 #include "base/json/json_value_serializer.h"
 #include "base/memory/scoped_handle.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"  // TODO(viettrungluu): delete me.
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_utility_messages.h"
-#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_unpacker.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/signature_verifier.h"
 #include "grit/generated_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 71 matching lines @@
     UNPACK_RATE_HISTOGRAM(
         "Extensions.SandboxUnpackRateOver10mB", unpack_rate_kb_per_s);
   }
 }
 
 }  // namespace
 
 SandboxedExtensionUnpacker::SandboxedExtensionUnpacker(
     const FilePath& crx_path,
     ResourceDispatcherHost* rdh,
+    Extension::Location location,
     int creation_flags,
     SandboxedExtensionUnpackerClient* client)
     : crx_path_(crx_path),
       thread_identifier_(BrowserThread::ID_COUNT),
       rdh_(rdh), client_(client), got_response_(false),
-      creation_flags_(creation_flags) {
+      location_(location), creation_flags_(creation_flags) {
 }
 
 bool SandboxedExtensionUnpacker::CreateTempDirectory() {
   CHECK(BrowserThread::GetCurrentThreadIdentifier(&thread_identifier_));
 
   FilePath user_data_temp_dir = extension_file_util::GetUserDataTempDir();
   if (user_data_temp_dir.empty()) {
     ReportFailure(
         COULD_NOT_GET_TEMP_DIRECTORY,
         l10n_util::GetStringFUTF8(
@@ skipping 76 matching lines @@
                           link_free_crx_path);
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &SandboxedExtensionUnpacker::StartProcessOnIOThread,
             this,
             link_free_crx_path));
   } else {
     // Otherwise, unpack the extension in this process.
-    ExtensionUnpacker unpacker(temp_crx_path);
+    ExtensionUnpacker unpacker(temp_crx_path, location_, creation_flags_);
     if (unpacker.Run() && unpacker.DumpImagesToFile() &&
         unpacker.DumpMessageCatalogsToFile()) {
       OnUnpackExtensionSucceeded(*unpacker.parsed_manifest());
     } else {
       OnUnpackExtensionFailed(unpacker.error_message());
     }
   }
 }
 
 SandboxedExtensionUnpacker::~SandboxedExtensionUnpacker() {
@@ skipping 27 matching lines @@
          IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
          ASCIIToUTF16("UTILITY_PROCESS_CRASHED_WHILE_TRYING_TO_INSTALL")));
 }
 
 void SandboxedExtensionUnpacker::StartProcessOnIOThread(
     const FilePath& temp_crx_path) {
   UtilityProcessHost* host = new UtilityProcessHost(this, thread_identifier_);
   // Grant the subprocess access to the entire subdir the extension file is
   // in, so that it can unpack to that dir.
   host->set_exposed_dir(temp_crx_path.DirName());
-  host->Send(new ChromeUtilityMsg_UnpackExtension(temp_crx_path));
+  host->Send(
+      new ChromeUtilityMsg_UnpackExtension(
+          temp_crx_path, location_, creation_flags_));
 }
 
 void SandboxedExtensionUnpacker::OnUnpackExtensionSucceeded(
     const DictionaryValue& manifest) {
   // Skip check for unittests.
   if (thread_identifier_ != BrowserThread::ID_COUNT)
     CHECK(BrowserThread::CurrentlyOn(thread_identifier_));
   got_response_ = true;
 
   scoped_ptr<DictionaryValue> final_manifest(RewriteManifestFile(manifest));
@@ skipping 13 matching lines @@
     ReportFailure(
         COULD_NOT_LOCALIZE_EXTENSION,
         l10n_util::GetStringFUTF8(
             IDS_EXTENSION_PACKAGE_ERROR_MESSAGE,
             ASCIIToUTF16(error)));
     return;
   }
 
   extension_ = Extension::Create(
       extension_root_,
-      Extension::INTERNAL,
+      location_,
       *final_manifest,
       Extension::REQUIRE_KEY | creation_flags_,
       &error);
 
   if (!extension_.get()) {
     ReportFailure(
         INVALID_MANIFEST,
         std::string("Manifest is invalid: ") + error);
     return;
   }
@@ skipping 399 matching lines @@
           ERROR_SAVING_CATALOG,
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
               ASCIIToUTF16("ERROR_SAVING_CATALOG")));
       return false;
     }
   }
 
   return true;
 }