Home | History | Annotate | Download | only in autotest_private 
      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 "extensions/browser/extension_function_registry.h"
     16 #include "extensions/browser/extension_registry.h"
     17 #include "extensions/browser/extension_system.h"
     18 #include "extensions/common/manifest_handlers/background_info.h"
     19 #include "extensions/common/manifest_handlers/options_page_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(
    178         "optionsUrl", OptionsPageInfo::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
    250