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

chrome/browser/extensions/api/developer_private/developer_private_api.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/api/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
@@ skipping 375 matching lines @@
               info->runtime_errors.push_back(make_linked_ptr(value.release()));
               break;
             }
             case ExtensionError::NUM_ERROR_TYPES:
               NOTREACHED();
               break;
           }
         }
       }
     } else {
-      for (std::vector<extensions::InstallWarning>::const_iterator it =
+      for (std::vector<InstallWarning>::const_iterator it =
                item.install_warnings().begin();
            it != item.install_warnings().end();
            ++it) {
         scoped_ptr<developer::InstallWarning> warning(
             new developer::InstallWarning);
         warning->message = it->message;
         info->install_warnings.push_back(make_linked_ptr(warning.release()));
       }
     }
   }
@@ skipping 12 matching lines @@
     info->options_url.reset(
         new std::string(ManifestURL::GetOptionsPage(&item).spec()));
   }
 
   if (!ManifestURL::GetUpdateURL(&item).is_empty()) {
     info->update_url.reset(
         new std::string(ManifestURL::GetUpdateURL(&item).spec()));
   }
 
   if (item.is_app()) {
-    info->app_launch_url.reset(new std::string(
-        extensions::AppLaunchInfo::GetFullLaunchURL(&item).spec()));
+    info->app_launch_url.reset(
+        new std::string(AppLaunchInfo::GetFullLaunchURL(&item).spec()));
   }
 
   info->may_disable = system->management_policy()->
       UserMayModifySettings(&item, NULL);
   info->is_app = item.is_app();
   info->views = GetInspectablePagesForExtension(&item, item_is_enabled);
 
   return info.Pass();
 }
 
@@ skipping 98 matching lines @@
   view->generated_background_page = generated_background_page;
   return view;
 }
 
 ItemInspectViewList DeveloperPrivateGetItemsInfoFunction::
     GetInspectablePagesForExtension(
         const Extension* extension,
         bool extension_is_enabled) {
   ItemInspectViewList result;
   // Get the extension process's active views.
-  extensions::ProcessManager* process_manager =
+  ProcessManager* process_manager =
       ExtensionSystem::Get(GetProfile())->process_manager();
   GetInspectablePagesForExtensionProcess(
       extension,
       process_manager->GetRenderViewHostsForExtension(extension->id()),
       &result);
 
   // Get app window views.
   GetAppWindowPagesForExtensionProfile(extension, &result);
 
   // Include a link to start the lazy background page, if applicable.
@@ skipping 36 matching lines @@
 }
 
 bool DeveloperPrivateGetItemsInfoFunction::RunAsync() {
   scoped_ptr<developer::GetItemsInfo::Params> params(
       developer::GetItemsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool include_disabled = params->include_disabled;
   bool include_terminated = params->include_terminated;
 
-  extensions::ExtensionSet items;
+  ExtensionSet items;
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(GetProfile());
 
   items.InsertAll(registry->enabled_extensions());
 
   if (include_disabled) {
     items.InsertAll(registry->disabled_extensions());
   }
 
   if (include_terminated) {
     items.InsertAll(registry->terminated_extensions());
   }
 
   ExtensionService* service =
       ExtensionSystem::Get(GetProfile())->extension_service();
   std::map<std::string, ExtensionResource> id_to_icon;
   ItemInfoList item_list;
 
-  for (extensions::ExtensionSet::const_iterator iter = items.begin();
-       iter != items.end(); ++iter) {
+  for (ExtensionSet::const_iterator iter = items.begin(); iter != items.end();
+       ++iter) {
     const Extension& item = *iter->get();
 
     ExtensionResource item_resource =
         IconsInfo::GetIconResource(&item,
                                    extension_misc::EXTENSION_ICON_MEDIUM,
                                    ExtensionIconSet::MATCH_BIGGER);
     id_to_icon[item.id()] = item_resource;
 
     // Don't show component extensions and invisible apps.
     if (item.ShouldNotBeVisible())
@@ skipping 17 matching lines @@
 
 bool DeveloperPrivateAllowFileAccessFunction::RunSync() {
   scoped_ptr<AllowFileAccess::Params> params(
       AllowFileAccess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   EXTENSION_FUNCTION_VALIDATE(user_gesture_);
 
   ExtensionSystem* system = ExtensionSystem::Get(GetProfile());
   ManagementPolicy* management_policy = system->management_policy();
-  ExtensionService* service = GetProfile()->GetExtensionService();
-  const Extension* extension = service->GetInstalledExtension(params->item_id);
+  const Extension* extension =
+      ExtensionRegistry::Get(GetProfile())
+          ->GetExtensionById(params->item_id, ExtensionRegistry::EVERYTHING);
   bool result = true;
 
   if (!extension) {
     result = false;
   } else if (!management_policy->UserMayModifySettings(extension, NULL)) {
     LOG(ERROR) << "Attempt to change allow file access of an extension that "
                << "non-usermanagable was made. Extension id : "
                << extension->id();
     result = false;
   } else {
     util::SetAllowFileAccess(extension->id(), GetProfile(), params->allow);
     result = true;
   }
 
   return result;
 }
 
 DeveloperPrivateAllowFileAccessFunction::
     ~DeveloperPrivateAllowFileAccessFunction() {}
 
 bool DeveloperPrivateAllowIncognitoFunction::RunSync() {
   scoped_ptr<AllowIncognito::Params> params(
       AllowIncognito::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  ExtensionService* service = GetProfile()->GetExtensionService();
-  const Extension* extension = service->GetInstalledExtension(params->item_id);
+  const Extension* extension =
+      ExtensionRegistry::Get(GetProfile())
+          ->GetExtensionById(params->item_id, ExtensionRegistry::EVERYTHING);
   bool result = true;
 
   if (!extension)
     result = false;
   else
     util::SetIsIncognitoEnabled(extension->id(), GetProfile(), params->allow);
 
   return result;
 }
 
 DeveloperPrivateAllowIncognitoFunction::
     ~DeveloperPrivateAllowIncognitoFunction() {}
 
 bool DeveloperPrivateReloadFunction::RunSync() {
   scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionService* service = GetProfile()->GetExtensionService();
   CHECK(!params->item_id.empty());
   service->ReloadExtension(params->item_id);
   return true;
 }
 
 bool DeveloperPrivateShowPermissionsDialogFunction::RunSync() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id_));
-  ExtensionService* service = GetProfile()->GetExtensionService();
   CHECK(!extension_id_.empty());
   AppWindowRegistry* registry = AppWindowRegistry::Get(GetProfile());
   DCHECK(registry);
   AppWindow* app_window =
       registry->GetAppWindowForRenderViewHost(render_view_host());
   prompt_.reset(new ExtensionInstallPrompt(app_window->web_contents()));
-  const Extension* extension = service->GetInstalledExtension(extension_id_);
+  const Extension* extension =
+      ExtensionRegistry::Get(GetProfile())
+          ->GetExtensionById(extension_id_, ExtensionRegistry::EVERYTHING);
 
   if (!extension)
     return false;
 
   // Released by InstallUIAbort or InstallUIProceed.
   AddRef();
   std::vector<base::FilePath> retained_file_paths;
-  if (extension->HasAPIPermission(extensions::APIPermission::kFileSystem)) {
+  if (extension->HasAPIPermission(APIPermission::kFileSystem)) {
     std::vector<apps::SavedFileEntry> retained_file_entries =
         apps::SavedFilesService::Get(GetProfile())
             ->GetAllFileEntries(extension_id_);
     for (size_t i = 0; i < retained_file_entries.size(); i++) {
       retained_file_paths.push_back(retained_file_entries[i].path);
     }
   }
   prompt_->ReviewPermissions(this, extension, retained_file_paths);
   return true;
 }
@@ skipping 27 matching lines @@
 DeveloperPrivateEnableFunction::DeveloperPrivateEnableFunction() {}
 
 bool DeveloperPrivateEnableFunction::RunSync() {
   scoped_ptr<Enable::Params> params(Enable::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string extension_id = params->item_id;
 
   ExtensionSystem* system = ExtensionSystem::Get(GetProfile());
   ManagementPolicy* policy = system->management_policy();
   ExtensionService* service = GetProfile()->GetExtensionService();

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

Since you're here, can you change this to system->extension_service()? 
Profile::GetExtensionService() is also deprecated...

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

Done.

 
-  const Extension* extension = service->GetInstalledExtension(extension_id);
+  const Extension* extension =
+      ExtensionRegistry::Get(GetProfile())
+          ->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
   if (!extension) {
     LOG(ERROR) << "Did not find extension with id " << extension_id;
     return false;
   }
   bool enable = params->enable;
   if (!policy->UserMayModifySettings(extension, NULL) ||
       (!enable && policy->MustRemainEnabled(extension, NULL)) ||
       (enable && policy->MustRemainDisabled(extension, NULL, NULL))) {
     LOG(ERROR) << "Attempt to change enable state denied by management policy. "
                << "Extension id: " << extension_id.c_str();
@@ skipping 560 matching lines @@
   }
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions