Migrates legacy packaged app data when it's upgraded to a platform app

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
 #include "base/command_line.h"
+#include "base/files/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/content_settings_custom_extension_provider.h"
@@ skipping 27 matching lines @@
 #include "chrome/browser/ui/webui/theme_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/url_constants.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/crx_file/id_util.h"
 #include "components/startup_metric_utils/startup_metric_utils.h"
 #include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/indexed_db_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/browser/update_observer.h"
 #include "extensions/browser/updater/extension_cache.h"
 #include "extensions/browser/updater/extension_downloader.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_url_handlers.h"
 #include "extensions/common/one_shot_event.h"
 #include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permissions_data.h"
+#include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
+#include "storage/common/database/database_identifier.h"
+#include "storage/common/fileapi/file_system_types.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/extensions/install_limiter.h"
 #include "storage/browser/fileapi/file_system_backend.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
@@ skipping 14 matching lines @@
 using extensions::SharedModuleService;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extensions::manifest_errors;
 
 namespace {
 
 // Wait this many seconds after an extensions becomes idle before updating it.
 const int kUpdateIdleDelay = 5;
 
+void CopyFileSystem(
+    storage::SandboxFileSystemBackendDelegate* old_sandbox_delegate,
+    storage::SandboxFileSystemBackendDelegate* sandbox_delegate,
+    const GURL& origin,
+    storage::FileSystemType type){
+
+  base::FilePath old_base_path =
+      old_sandbox_delegate->GetBaseDirectoryForOriginAndType(
+          origin,
+          type,
+          false);
+
+  base::FilePath base_path =
+      sandbox_delegate->GetBaseDirectoryForOriginAndType(
+          origin,
+          type,
+          true);
+
+  base::CopyDirectory(old_base_path, base_path.DirName(), true);
+}
+
+void MigrateLegacyPartition(
+    content::StoragePartition* old_partition,
+    content::StoragePartition* current_partition,
+    const Extension* extension) {
+  GURL extension_url = Extension::GetBaseURLFromExtensionId(extension->id());

[benwells, 2014/11/03 00:08:41]

Could you add a check here that this is happening on the correct thread?

[ryanackley, 2014/11/04 22:51:54]

Acknowledged.

+
+  content::IndexedDBContext* indexed_db_context =
+      current_partition->GetIndexedDBContext();
+  content::IndexedDBContext* old_indexed_db_context =
+      old_partition->GetIndexedDBContext();
+
+  base::FilePath old_db_path =
+      old_indexed_db_context->GetFilePath(extension_url);
+  base::FilePath current_db_path =
+      indexed_db_context->GetFilePath(extension_url);
+
+  if (base::PathExists(old_db_path) && !base::PathExists(current_db_path)){
+    base::CopyDirectory(old_db_path, current_db_path.DirName(), true);
+  }
+
+  storage::FileSystemContext* old_fs_context =
+      old_partition->GetFileSystemContext();
+  storage::FileSystemContext* fs_context =
+      current_partition->GetFileSystemContext();
+
+  storage::SandboxFileSystemBackendDelegate* old_sandbox_delegate =
+      old_fs_context->sandbox_delegate();
+  storage::SandboxFileSystemBackendDelegate* sandbox_delegate =
+      fs_context->sandbox_delegate();
+
+  scoped_ptr<storage::SandboxFileSystemBackendDelegate::OriginEnumerator>
+      enumerator(old_sandbox_delegate->CreateOriginEnumerator());
+
+  GURL origin;
+  while (extension_url != (origin = enumerator->Next()) && !origin.is_empty()){

[benwells, 2014/11/03 00:08:41]

Nit: you need a space before the curly (here and elsewhere). But you also don't
need these curies at all.

Nit: having an assignment in a conditional is generally yuck. I'd redo this to
avoid that.

[ryanackley, 2014/11/04 22:51:53]

Acknowledged.

+    continue;
+  }
+  if (!origin.is_empty()){
+    if (enumerator->HasFileSystemType(storage::kFileSystemTypeTemporary)){
+      CopyFileSystem(
+          old_sandbox_delegate,
+          sandbox_delegate,
+          extension_url,
+          storage::kFileSystemTypeTemporary);
+    }
+    if (enumerator->HasFileSystemType(storage::kFileSystemTypePersistent)){
+      CopyFileSystem(
+          old_sandbox_delegate,
+          sandbox_delegate,
+          extension_url,
+          storage::kFileSystemTypePersistent);
+    }
+  }
+}
+
 }  // namespace
 
 // ExtensionService.
 
 void ExtensionService::CheckExternalUninstall(const std::string& id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the providers know about this extension.
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
@@ skipping 1206 matching lines @@
   }
 
   bool is_extension_upgrade = false;
   bool is_extension_installed = false;
   const Extension* old = GetInstalledExtension(extension->id());
   if (old) {
     is_extension_installed = true;
     int version_compare_result =
         extension->version()->CompareTo(*(old->version()));
     is_extension_upgrade = version_compare_result > 0;
+
     // Other than for unpacked extensions, CrxInstaller should have guaranteed
     // that we aren't downgrading.
     if (!Manifest::IsUnpackedLocation(extension->location()))
       CHECK_GE(version_compare_result, 0);
   }
   system_->runtime_data()->SetBeingUpgraded(extension, is_extension_upgrade);
 
   // The extension is now loaded, remove its data from unloaded extension map.
   unloaded_extension_paths_.erase(extension->id());
 
@@ skipping 53 matching lines @@
           extension->id(),
           extension->ShouldDisplayInNewTabPage() &&
               !extension_prefs_->IsEphemeralApp(extension->id()));
       if (!extension_prefs_->IsEphemeralApp(extension->id())) {
         extension_prefs_->app_sorting()->EnsureValidOrdinals(
             extension->id(), syncer::StringOrdinal());
       }
     }
 
     registry_->AddEnabled(extension);
+
     if (extension_sync_service_)
       extension_sync_service_->SyncExtensionChangeIfNeeded(*extension);
     NotifyExtensionLoaded(extension);
   }
+
   system_->runtime_data()->SetBeingUpgraded(extension, false);
 }
 
 void ExtensionService::AddComponentExtension(const Extension* extension) {
   const std::string old_version_string(
       extension_prefs_->GetVersionString(extension->id()));
   const Version old_version(old_version_string);
 
   VLOG(1) << "AddComponentExtension " << extension->name();
   if (!old_version.IsValid() || !old_version.Equals(*extension->version())) {
@@ skipping 274 matching lines @@
                              page_ordinal,
                              install_parameter);
   }
 }
 
 void ExtensionService::OnExtensionManagementSettingsChanged() {
   error_controller_->ShowErrorIfNeeded();
   CheckManagementPolicy();
 }
 
+bool ExtensionService::NeedsMigration(const Extension* extension){

[benwells, 2014/11/03 00:08:41]

Could all the new logic you're adding go in a new file / class - Extension? It
would be on ExtensionService as a field. This file is kind of big and ugly and
this is adding more dependencies out onto other bits of code.

[benwells, 2014/11/03 00:08:42]

Can you add a check here that this is happening on the UI thread?

[ryanackley, 2014/11/04 22:51:54]

Acknowledged.

[ryanackley, 2014/11/04 22:51:54]

Acknowledged.

+  const Extension* old = GetInstalledExtension(extension->id());
+  return old && old->is_legacy_packaged_app() && extension->is_platform_app();
+}
+
+void ExtensionService::MigrateThenFinishInstallation(
+      const Extension* extension,
+      bool was_ephemeral){
+
+  const Extension* old = GetInstalledExtension(extension->id());
+
+  // juggle the enabled status of the new and old extensions so we can get
+  // the old and new storage partitions
+  content::StoragePartition* old_partition =
+      BrowserContext::GetStoragePartitionForSite(
+          profile_,
+          Extension::GetBaseURLFromExtensionId(extension->id()));
+  bool oldWasDisabled = registry_->AddEnabled(extension);
+  content::StoragePartition* new_partition =
+      BrowserContext::GetStoragePartitionForSite(
+          profile_,
+          Extension::GetBaseURLFromExtensionId(extension->id()));
+
+  if (!oldWasDisabled){
+    registry_->AddEnabled(old);
+  }else{
+    registry_->RemoveEnabled(extension->id());
+  }
+
+  BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE,

[benwells, 2014/11/03 00:08:41]

Could you use the blocking pool instead? See
https://code.google.com/p/chromium/codesearch#chromium/src/content/public/bro...
and callers for how to use it.

The blocking pool is a replacement of the FILE thread.

[ryanackley, 2014/11/04 22:51:54]

Acknowledged.

+      base::Bind(
+          &MigrateLegacyPartition,
+          old_partition,
+          new_partition,
+          make_scoped_refptr(extension)),
+      base::Bind(
+          &ExtensionService::FinishInstallation,
+          AsWeakPtr(),
+          make_scoped_refptr(extension),
+          was_ephemeral));
+}
+
 void ExtensionService::AddNewOrUpdatedExtension(
     const Extension* extension,
     Extension::State initial_state,
     int install_flags,
     const syncer::StringOrdinal& page_ordinal,
     const std::string& install_parameter) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool was_ephemeral = extension_prefs_->IsEphemeralApp(extension->id());
   extension_prefs_->OnExtensionInstalled(
       extension, initial_state, page_ordinal, install_flags, install_parameter);
   delayed_installs_.Remove(extension->id());
   if (InstallVerifier::NeedsVerification(*extension))
     system_->install_verifier()->VerifyExtension(extension->id());
-  FinishInstallation(extension, was_ephemeral);
+
+  if (NeedsMigration(extension)){

[benwells, 2014/11/03 00:08:42]

The patter chrome tends to use here is more like:

  if (blah) {
    blab();
    return;
  }

  otherblab();
}

[ryanackley, 2014/11/04 22:51:54]

Acknowledged.

+    MigrateThenFinishInstallation(extension, was_ephemeral);
+  }else{
+    FinishInstallation(extension, was_ephemeral);
+  }
+
 }
 
 void ExtensionService::MaybeFinishDelayedInstallation(
     const std::string& extension_id) {
   // Check if the extension already got installed.
   if (!delayed_installs_.Contains(extension_id))
     return;
   extensions::ExtensionPrefs::DelayReason reason =
       extension_prefs_->GetDelayedInstallReason(extension_id);
 
@@ skipping 632 matching lines @@
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }