Revert of Enable forced extension updates on NaCl arch mismatch

extensions/common/extension.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 "extensions/common/extension.h"
 
-#include <algorithm>
-
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
-#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
-#include "base/files/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 37 matching lines @@
   // We should disallow backslash '\\' as file path separator even on Windows,
   // because the backslash is not regarded as file path separator on Linux/Mac.
   // Extensions are cross-platform.
   // Since FilePath uses backslash '\\' as file path separator on Windows, so we
   // need to check manually.
   if (path.value().find('\\') != path.value().npos)
     return true;
   return !net::IsSafePortableRelativePath(path);
 }
 
-void CollectPlatformSpecificResourceArchs(const base::FilePath& extension_path,
-                                          std::set<std::string>* archs) {
-  archs->clear();
-  base::FilePath platform_specific_path = extension_path.Append(
-      kPlatformSpecificFolder);
-  if (!base::PathExists(platform_specific_path)) {
-    return;
-  }
-
-  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);
-  }
-}
-
 }  // namespace
 
 const int Extension::kInitFromValueFlagBits = 13;
 
 const char Extension::kMimeType[] = "application/x-chrome-extension";
 
 const int Extension::kValidWebExtentSchemes =
     URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS;
 
 const int Extension::kValidHostPermissionSchemes = URLPattern::SCHEME_CHROMEUI |
@@ skipping 350 matching lines @@
 }
 
 void Extension::AddWebExtentPattern(const URLPattern& pattern) {
   // Bookmark apps are permissionless.
   if (from_bookmark())
     return;
 
   extent_.AddPattern(pattern);
 }
 
-bool Extension::HasPlatformSpecificResources() const {
-  return !platform_specific_resource_archs_.empty();
-}
-
-bool Extension::HasResourcesForPlatform(const std::string& arch) const {
-  return platform_specific_resource_archs_.find(arch) !=
-      platform_specific_resource_archs_.end();
-}
-
 // static
 bool Extension::InitExtensionID(extensions::Manifest* manifest,
                                 const base::FilePath& path,
                                 const std::string& explicit_id,
                                 int creation_flags,
                                 base::string16* error) {
   if (!explicit_id.empty()) {
     manifest->set_extension_id(explicit_id);
     return true;
   }
@@ skipping 81 matching lines @@
   if (!LoadSharedFeatures(error))
     return false;
 
   permissions_parser_->Finalize(this);
   permissions_parser_.reset();
 
   finished_parsing_manifest_ = true;
 
   permissions_data_.reset(new PermissionsData(this));
 
-  CollectPlatformSpecificResourceArchs(path_,
-                                       &platform_specific_resource_archs_);
-
   return true;
 }
 
 bool Extension::LoadRequiredFeatures(base::string16* error) {
   if (!LoadName(error) ||
       !LoadVersion(error))
     return false;
   return true;
 }
 
@@ skipping 214 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions