src/chrome/browser/extensions/api/autotest_private/autotest_private_api.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/autotest_private/autotest_private_api.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "chrome/browser/extensions/extension_action_manager.h"
  10 #include "chrome/browser/extensions/extension_service.h"
  11 #include "chrome/browser/extensions/extension_util.h"
  12 #include "chrome/browser/lifetime/application_lifetime.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/common/extensions/api/autotest_private.h"
  15 #include "chrome/common/extensions/manifest_url_handler.h"
  16 #include "extensions/browser/extension_function_registry.h"
  17 #include "extensions/browser/extension_registry.h"
  18 #include "extensions/browser/extension_system.h"
  19 #include "extensions/common/manifest_handlers/background_info.h"
  20 #include "extensions/common/permissions/api_permission_set.h"
  21 #include "extensions/common/permissions/permission_set.h"
  22 #include "extensions/common/permissions/permissions_data.h"
  23
  24 #if defined(OS_CHROMEOS)
  25 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
  26 #include "chromeos/dbus/dbus_thread_manager.h"
  27 #include "chromeos/dbus/session_manager_client.h"
  28 #include "components/user_manager/user.h"
  29 #include "components/user_manager/user_manager.h"
  30 #endif
  31
  32 namespace extensions {
  33 namespace {
  34
  35 base::ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
  36   const PermissionsData* permissions_data = ext->permissions_data();
  37   const URLPatternSet& pattern_set =
  38       effective_perm ? permissions_data->GetEffectiveHostPermissions()
  39                      : permissions_data->active_permissions()->explicit_hosts();
  40
  41   base::ListValue* permissions = new base::ListValue;
  42   for (URLPatternSet::const_iterator perm = pattern_set.begin();
  43        perm != pattern_set.end();
  44        ++perm) {
  45     permissions->Append(new base::StringValue(perm->GetAsString()));
  46   }
  47
  48   return permissions;
  49 }
  50
  51 base::ListValue* GetAPIPermissions(const Extension* ext) {
  52   base::ListValue* permissions = new base::ListValue;
  53   std::set<std::string> perm_list =
  54       ext->permissions_data()->active_permissions()->GetAPIsAsStrings();
  55   for (std::set<std::string>::const_iterator perm = perm_list.begin();
  56        perm != perm_list.end(); ++perm) {
  57     permissions->Append(new base::StringValue(perm->c_str()));
  58   }
  59   return permissions;
  60 }
  61
  62 bool IsTestMode(Profile* profile) {
  63   return AutotestPrivateAPI::GetFactoryInstance()->Get(profile)->test_mode();
  64 }
  65
  66 }  // namespace
  67
  68 bool AutotestPrivateLogoutFunction::RunSync() {
  69   DVLOG(1) << "AutotestPrivateLogoutFunction";
  70   if (!IsTestMode(GetProfile()))
  71     chrome::AttemptUserExit();
  72   return true;
  73 }
  74
  75 bool AutotestPrivateRestartFunction::RunSync() {
  76   DVLOG(1) << "AutotestPrivateRestartFunction";
  77   if (!IsTestMode(GetProfile()))
  78     chrome::AttemptRestart();
  79   return true;
  80 }
  81
  82 bool AutotestPrivateShutdownFunction::RunSync() {
  83   scoped_ptr<api::autotest_private::Shutdown::Params> params(
  84       api::autotest_private::Shutdown::Params::Create(*args_));
  85   EXTENSION_FUNCTION_VALIDATE(params.get());
  86
  87   DVLOG(1) << "AutotestPrivateShutdownFunction " << params->force;
  88
  89   if (!IsTestMode(GetProfile()))
  90     chrome::AttemptExit();
  91   return true;
  92 }
  93
  94 bool AutotestPrivateLoginStatusFunction::RunSync() {
  95   DVLOG(1) << "AutotestPrivateLoginStatusFunction";
  96
  97   base::DictionaryValue* result(new base::DictionaryValue);
  98 #if defined(OS_CHROMEOS)
  99   const user_manager::UserManager* user_manager =
 100       user_manager::UserManager::Get();
 101   const bool is_screen_locked =
 102       !!chromeos::ScreenLocker::default_screen_locker();
 103
 104   if (user_manager) {
 105     result->SetBoolean("isLoggedIn", user_manager->IsUserLoggedIn());
 106     result->SetBoolean("isOwner", user_manager->IsCurrentUserOwner());
 107     result->SetBoolean("isScreenLocked", is_screen_locked);
 108     if (user_manager->IsUserLoggedIn()) {
 109       result->SetBoolean("isRegularUser",
 110                          user_manager->IsLoggedInAsRegularUser());
 111       result->SetBoolean("isGuest", user_manager->IsLoggedInAsGuest());
 112       result->SetBoolean("isKiosk", user_manager->IsLoggedInAsKioskApp());
 113
 114       const user_manager::User* user = user_manager->GetLoggedInUser();
 115       result->SetString("email", user->email());
 116       result->SetString("displayEmail", user->display_email());
 117
 118       std::string user_image;
 119       switch (user->image_index()) {
 120         case user_manager::User::USER_IMAGE_EXTERNAL:
 121           user_image = "file";
 122           break;
 123
 124         case user_manager::User::USER_IMAGE_PROFILE:
 125           user_image = "profile";
 126           break;
 127
 128         default:
 129           user_image = base::IntToString(user->image_index());
 130           break;
 131       }
 132       result->SetString("userImage", user_image);
 133     }
 134   }
 135 #endif
 136
 137   SetResult(result);
 138   return true;
 139 }
 140
 141 bool AutotestPrivateLockScreenFunction::RunSync() {
 142   DVLOG(1) << "AutotestPrivateLockScreenFunction";
 143 #if defined(OS_CHROMEOS)
 144   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
 145       RequestLockScreen();
 146 #endif
 147   return true;
 148 }
 149
 150 bool AutotestPrivateGetExtensionsInfoFunction::RunSync() {
 151   DVLOG(1) << "AutotestPrivateGetExtensionsInfoFunction";
 152
 153   ExtensionService* service =
 154       ExtensionSystem::Get(GetProfile())->extension_service();
 155   ExtensionRegistry* registry = ExtensionRegistry::Get(GetProfile());
 156   const ExtensionSet& extensions = registry->enabled_extensions();
 157   const ExtensionSet& disabled_extensions = registry->disabled_extensions();
 158   ExtensionActionManager* extension_action_manager =
 159       ExtensionActionManager::Get(GetProfile());
 160
 161   base::ListValue* extensions_values = new base::ListValue;
 162   ExtensionList all;
 163   all.insert(all.end(), extensions.begin(), extensions.end());
 164   all.insert(all.end(), disabled_extensions.begin(), disabled_extensions.end());
 165   for (ExtensionList::const_iterator it = all.begin();
 166        it != all.end(); ++it) {
 167     const Extension* extension = it->get();
 168     std::string id = extension->id();
 169     base::DictionaryValue* extension_value = new base::DictionaryValue;
 170     extension_value->SetString("id", id);
 171     extension_value->SetString("version", extension->VersionString());
 172     extension_value->SetString("name", extension->name());
 173     extension_value->SetString("publicKey", extension->public_key());
 174     extension_value->SetString("description", extension->description());
 175     extension_value->SetString(
 176         "backgroundUrl", BackgroundInfo::GetBackgroundURL(extension).spec());
 177     extension_value->SetString("optionsUrl",
 178                                ManifestURL::GetOptionsPage(extension).spec());
 179
 180     extension_value->Set("hostPermissions",
 181                          GetHostPermissions(extension, false));
 182     extension_value->Set("effectiveHostPermissions",
 183                          GetHostPermissions(extension, true));
 184     extension_value->Set("apiPermissions", GetAPIPermissions(extension));
 185
 186     Manifest::Location location = extension->location();
 187     extension_value->SetBoolean("isComponent",
 188                                 location == Manifest::COMPONENT);
 189     extension_value->SetBoolean("isInternal",
 190                                 location == Manifest::INTERNAL);
 191     extension_value->SetBoolean("isUserInstalled",
 192         location == Manifest::INTERNAL ||
 193         Manifest::IsUnpackedLocation(location));
 194     extension_value->SetBoolean("isEnabled", service->IsExtensionEnabled(id));
 195     extension_value->SetBoolean("allowedInIncognito",
 196         util::IsIncognitoEnabled(id, GetProfile()));
 197     extension_value->SetBoolean(
 198         "hasPageAction",
 199         extension_action_manager->GetPageAction(*extension) != NULL);
 200
 201     extensions_values->Append(extension_value);
 202   }
 203
 204   base::DictionaryValue* return_value(new base::DictionaryValue);
 205   return_value->Set("extensions", extensions_values);
 206   SetResult(return_value);
 207   return true;
 208 }
 209
 210 static int AccessArray(const volatile int arr[], const volatile int *index) {
 211   return arr[*index];
 212 }
 213
 214 bool AutotestPrivateSimulateAsanMemoryBugFunction::RunSync() {
 215   DVLOG(1) << "AutotestPrivateSimulateAsanMemoryBugFunction";
 216   if (!IsTestMode(GetProfile())) {
 217     // This array is volatile not to let compiler optimize us out.
 218     volatile int testarray[3] = {0, 0, 0};
 219
 220     // Cause Address Sanitizer to abort this process.
 221     volatile int index = 5;
 222     AccessArray(testarray, &index);
 223   }
 224   return true;
 225 }
 226
 227 static base::LazyInstance<BrowserContextKeyedAPIFactory<AutotestPrivateAPI> >
 228     g_factory = LAZY_INSTANCE_INITIALIZER;
 229
 230 // static
 231 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>*
 232 AutotestPrivateAPI::GetFactoryInstance() {
 233   return g_factory.Pointer();
 234 }
 235
 236 template <>
 237 KeyedService*
 238 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>::BuildServiceInstanceFor(
 239     content::BrowserContext* context) const {
 240   return new AutotestPrivateAPI();
 241 }
 242
 243 AutotestPrivateAPI::AutotestPrivateAPI() : test_mode_(false) {
 244 }
 245
 246 AutotestPrivateAPI::~AutotestPrivateAPI() {
 247 }
 248
 249 }  // namespace extensions