Change AlarmManager to use ProfileKeyedAPI.

chrome/browser/extensions/api/alarms/alarms_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/alarms/alarms_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
-#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/common/extensions/api/alarms.h"
 #include "extensions/common/error_utils.h"
 
 namespace alarms = extensions::api::alarms;
 
 namespace extensions {
 
 namespace {
 
 const char kDefaultAlarmName[] = "";
@@ skipping 90 matching lines @@
   for (std::vector<std::string>::const_iterator it = warnings.begin();
        it != warnings.end(); ++it)
     WriteToConsole(content::CONSOLE_MESSAGE_LEVEL_WARNING, *it);
 
   Alarm alarm(alarm_name,
               params->alarm_info,
               base::TimeDelta::FromMinutes(
                   Manifest::IsUnpackedLocation(GetExtension()->location()) ?
                   kDevDelayMinimum : kReleaseDelayMinimum),
               clock_->Now());
-  ExtensionSystem::Get(profile())->alarm_manager()->AddAlarm(
-      extension_id(), alarm);
+  AlarmManager::Get(profile())->AddAlarm(extension_id(), alarm);
 
   return true;
 }
 
 bool AlarmsGetFunction::RunImpl() {
   scoped_ptr<alarms::Get::Params> params(alarms::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
   const Alarm* alarm =
-      ExtensionSystem::Get(profile())->alarm_manager()->GetAlarm(
-          extension_id(), name);
+      AlarmManager::Get(profile())->GetAlarm(extension_id(), name);
 
   if (!alarm) {
     error_ = ErrorUtils::FormatErrorMessage(kAlarmNotFound, name);
     return false;
   }
 
   results_ = alarms::Get::Results::Create(*alarm->js_alarm);
   return true;
 }
 
 bool AlarmsGetAllFunction::RunImpl() {
   const AlarmManager::AlarmList* alarms =
-      ExtensionSystem::Get(profile())->alarm_manager()->GetAllAlarms(
-          extension_id());
+      AlarmManager::Get(profile())->GetAllAlarms(extension_id());
   if (alarms) {
     std::vector<linked_ptr<extensions::api::alarms::Alarm> > create_arg;
     create_arg.reserve(alarms->size());
     for (size_t i = 0, size = alarms->size(); i < size; ++i) {
       create_arg.push_back((*alarms)[i].js_alarm);
     }
     results_ = alarms::GetAll::Results::Create(create_arg);
   } else {
     SetResult(new base::ListValue());
   }
   return true;
 }
 
 bool AlarmsClearFunction::RunImpl() {
   scoped_ptr<alarms::Clear::Params> params(
       alarms::Clear::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
-  bool success = ExtensionSystem::Get(profile())->alarm_manager()->RemoveAlarm(
-     extension_id(), name);
+  bool success = AlarmManager::Get(profile())->RemoveAlarm(extension_id(),
+                                                           name);
 
   if (!success) {
     error_ = ErrorUtils::FormatErrorMessage(kAlarmNotFound, name);
     return false;
   }
 
   return true;
 }
 
 bool AlarmsClearAllFunction::RunImpl() {
-  ExtensionSystem::Get(profile())->alarm_manager()->RemoveAllAlarms(
-     extension_id());
+  AlarmManager::Get(profile())->RemoveAllAlarms(extension_id());
   return true;
 }
 
 }  // namespace extensions