Enable forced extension updates on NaCl arch mismatch.

chrome/browser/extensions/installed_loader.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/installed_loader.h"
 
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 131 matching lines @@
   if (reasons == Extension::DISABLE_NONE) {
     RecordDisbleReasonHistogram(Extension::DISABLE_NONE);
     return;
   }
   for (int reason = 1; reason < Extension::DISABLE_REASON_LAST; reason <<= 1) {
     if (reasons & reason)
       RecordDisbleReasonHistogram(reason);
   }
 }
 
+void RespondWithPlatformSpecificResourceArchs(
+    const base::Callback<void(const std::set<std::string>&)>& callback,
+    scoped_ptr<std::set<std::string> > archs) {
+  callback.Run(*archs.get());
+}
+
+void CollectPlatformSpecificResourceArchsOnBlockingPool(
+    const base::FilePath& extension_path,
+    const base::Callback<void(const std::set<std::string>&)>& callback) {
+  scoped_ptr<std::set<std::string > > archs(new std::set<std::string>());
+  base::FilePath platform_specific_path = extension_path.Append(
+      kPlatformSpecificFolder);
+  if (base::PathExists(platform_specific_path)) {
+    base::FileEnumerator all_archs(platform_specific_path,
+                                   false,
+                                   base::FileEnumerator::DIRECTORIES);
+    base::FilePath arch;
+    while (!(arch = all_archs.Next()).empty()) {
+      std::string arch_name = arch.BaseName().AsUTF8Unsafe();
+      std::replace(arch_name.begin(), arch_name.end(), '_', '-');
+      archs->insert(arch_name);
+    }
+  }
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&RespondWithPlatformSpecificResourceArchs,
+                 callback,
+                 base::Passed(&archs)));
+}
+
+void CollectPlatformSpecificResourceArchs(scoped_refptr<Extension> extension) {
+  BrowserThread::PostBlockingPoolTask(
+      FROM_HERE,
+      base::Bind(&CollectPlatformSpecificResourceArchsOnBlockingPool,
+                 extension->path(),
+                 base::Bind(&Extension::SetPlatformSpecificResourceArchs,
+                            extension)));
+}
+
 }  // namespace
 
 InstalledLoader::InstalledLoader(ExtensionService* extension_service)
     : extension_service_(extension_service),
       extension_registry_(ExtensionRegistry::Get(extension_service->profile())),
       extension_prefs_(ExtensionPrefs::Get(extension_service->profile())) {}
 
 InstalledLoader::~InstalledLoader() {
 }
 
 void InstalledLoader::Load(const ExtensionInfo& info, bool write_to_prefs) {
   std::string error;
-  scoped_refptr<const Extension> extension(NULL);
+  scoped_refptr<Extension> extension(NULL);
   if (info.extension_manifest) {
     extension = Extension::Create(
         info.extension_path,
         info.extension_location,
         *info.extension_manifest,
         GetCreationFlags(&info),
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
@@ skipping 36 matching lines @@
         error,
         extension_service_->profile(),
         false);  // Be quiet.
     return;
   }
 
   if (write_to_prefs)
     extension_prefs_->UpdateManifest(extension.get());
 
   extension_service_->AddExtension(extension.get());
+
+  CollectPlatformSpecificResourceArchs(extension);
 }
 
 void InstalledLoader::LoadAllExtensions() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   Profile* profile = extension_service_->profile();
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
@@ skipping 337 matching lines @@
 int InstalledLoader::GetCreationFlags(const ExtensionInfo* info) {
   int flags = extension_prefs_->GetCreationFlags(info->extension_id);
   if (!Manifest::IsUnpackedLocation(info->extension_location))
     flags |= Extension::REQUIRE_KEY;
   if (extension_prefs_->AllowFileAccess(info->extension_id))
     flags |= Extension::ALLOW_FILE_ACCESS;
   return flags;
 }
 
 }  // namespace extensions