clenaup: Removed deprecated GetInstalledExtension function from c/b/e/api

chrome/browser/extensions/api/declarative/rules_cache_delegate.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/api/declarative/rules_cache_delegate.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/declarative/rules_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/info_map.h"
 
 namespace {
 
 // Returns the key to use for storing declarative rules in the state store.
 std::string GetDeclarativeRuleStorageKey(const std::string& event_name,
                                          bool incognito) {
   if (incognito)
     return "declarative_rules.incognito." + event_name;
@@ skipping 43 matching lines @@
 
   profile_ = registry->profile();
   storage_key_ =
       GetDeclarativeRuleStorageKey(registry->event_name(),
                                    profile_->IsOffTheRecord());
   rules_stored_key_ = GetRulesStoredKey(registry->event_name(),
                                         profile_->IsOffTheRecord());
   rules_registry_thread_ = registry->owner_thread();
 
   ExtensionSystem& system = *ExtensionSystem::Get(profile_);
-  extensions::StateStore* store = system.rules_store();
+  StateStore* store = system.rules_store();
   if (store)
     store->RegisterKey(storage_key_);
 
   if (profile_->IsOffTheRecord())
     log_storage_init_delay_ = false;
 
   system.ready().Post(
       FROM_HERE,
       base::Bind(&RulesCacheDelegate::ReadRulesForInstalledExtensions,
                  weak_ptr_factory_.GetWeakPtr()));
@@ skipping 66 matching lines @@
   if (log_storage_init_delay_ && storage_init_time_.is_null())
     storage_init_time_ = base::Time::Now();
 
   if (!GetDeclarativeRulesStored(extension_id)) {
     ExtensionSystem::Get(profile_)->ready().Post(
         FROM_HERE, base::Bind(&RulesCacheDelegate::CheckIfReady,
                               weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
-  extensions::StateStore* store = ExtensionSystem::Get(profile_)->rules_store();
+  StateStore* store = ExtensionSystem::Get(profile_)->rules_store();
   if (!store)
     return;
   waiting_for_extensions_.insert(extension_id);
   store->GetExtensionValue(
       extension_id,
       storage_key_,
       base::Bind(&RulesCacheDelegate::ReadFromStorageCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  extension_id));
 }
@@ skipping 30 matching lines @@
 
   // Safe default -- if we don't know that the rules are not stored, we force
   // a read by returning true.
   return true;
 }
 
 void RulesCacheDelegate::SetDeclarativeRulesStored(
     const std::string& extension_id,
     bool rules_stored) {
   CHECK(profile_);
-  ExtensionSystem& system = *ExtensionSystem::Get(profile_);
-  ExtensionService* extension_service = system.extension_service();
-  DCHECK(extension_service);
-  DCHECK(extension_service->GetInstalledExtension(extension_id));
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);

[Devlin, 2014/05/22 22:09:12]

Could you inline this?
DCHECK(ExtensionRegistry::Get(profile_)->GetExtensionById(
           extension_id, ExtensionRegistry::EVERYTHING));

[limasdf, 2014/05/23 15:19:41]

Done.

+  DCHECK(
+      registry->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING));
+
   ExtensionScopedPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
   extension_prefs->UpdateExtensionPref(
       extension_id,
       rules_stored_key_,
       new base::FundamentalValue(rules_stored));
 }
 
 }  // namespace extensions