Extensions: Move id_util functions to crx_file component.

chrome/browser/extensions/error_console/error_console.cc

 // Copyright 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/error_console/error_console.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/pref_names.h"
+#include "components/crx_file/id_util.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/feature_switch.h"
@@ skipping 40 matching lines @@
 
 // static
 ErrorConsole* ErrorConsole::Get(Profile* profile) {
   return ExtensionSystem::Get(profile)->error_console();
 }
 
 void ErrorConsole::SetReportingForExtension(const std::string& extension_id,
                                             ExtensionError::Type type,
                                             bool enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!enabled_ || !Extension::IdIsValid(extension_id))
+  if (!enabled_ || !crx_file::id_util::IdIsValid(extension_id))
     return;
 
   int mask = default_mask_;
   // This call can fail if the preference isn't set, but we don't really care
   // if it does, because we just use the default mask instead.
   prefs_->ReadPrefAsInteger(extension_id, kStoreExtensionErrorsPref, &mask);
 
   if (enabled)
     mask |= 1 << type;
   else
     mask &= ~(1 << type);
 
   prefs_->UpdateExtensionPref(extension_id,
                               kStoreExtensionErrorsPref,
                               new base::FundamentalValue(mask));
 }
 
 void ErrorConsole::SetReportingAllForExtension(
     const std::string& extension_id, bool enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!enabled_ || !Extension::IdIsValid(extension_id))
+  if (!enabled_ || !crx_file::id_util::IdIsValid(extension_id))
     return;
 
   int mask = 0;
   if (enabled)
     mask = (1 << ExtensionError::NUM_ERROR_TYPES) - 1;
 
   prefs_->UpdateExtensionPref(extension_id,
                               kStoreExtensionErrorsPref,
                               new base::FundamentalValue(mask));
 }
 
 bool ErrorConsole::IsReportingEnabledForExtension(
     const std::string& extension_id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!enabled_ || !Extension::IdIsValid(extension_id))
+  if (!enabled_ || !crx_file::id_util::IdIsValid(extension_id))
     return false;
 
   return GetMaskForExtension(extension_id) != 0;
 }
 
 void ErrorConsole::UseDefaultReportingForExtension(
     const std::string& extension_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!enabled_ || !Extension::IdIsValid(extension_id))
+  if (!enabled_ || !crx_file::id_util::IdIsValid(extension_id))
     return;
 
   prefs_->UpdateExtensionPref(extension_id, kStoreExtensionErrorsPref, NULL);
 }
 
 void ErrorConsole::ReportError(scoped_ptr<ExtensionError> error) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!enabled_ || !Extension::IdIsValid(error->extension_id()))
+  if (!enabled_ || !crx_file::id_util::IdIsValid(error->extension_id()))
     return;
 
   int mask = GetMaskForExtension(error->extension_id());
   if (!(mask & (1 << error->type())))
     return;
 
   const ExtensionError* weak_error = errors_.AddError(error.Pass());
   FOR_EACH_OBSERVER(Observer, observers_, OnErrorAdded(weak_error));
 }
 
@@ skipping 130 matching lines @@
       ExtensionRegistry::Get(profile_)->GetExtensionById(
           extension_id, ExtensionRegistry::EVERYTHING);
   if (extension && extension->location() == Manifest::UNPACKED)
     return (1 << ExtensionError::NUM_ERROR_TYPES) - 1;
 
   // Otherwise, use the default mask.
   return default_mask_;
 }
 
 }  // namespace extensions