OLD | NEW |
| (Empty) |
1 // Copyright 2014 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/signin/screenlock_bridge.h" | |
6 | |
7 #include "base/logging.h" | |
8 #include "base/strings/string16.h" | |
9 #include "chrome/browser/profiles/profile_window.h" | |
10 #include "chrome/browser/signin/signin_manager_factory.h" | |
11 #include "components/signin/core/browser/signin_manager.h" | |
12 | |
13 #if defined(OS_CHROMEOS) | |
14 #include "chromeos/dbus/dbus_thread_manager.h" | |
15 #include "chromeos/dbus/session_manager_client.h" | |
16 #endif | |
17 | |
18 namespace { | |
19 | |
20 base::LazyInstance<ScreenlockBridge> g_screenlock_bridge_bridge_instance = | |
21 LAZY_INSTANCE_INITIALIZER; | |
22 | |
23 // Ids for the icons that are supported by lock screen and signin screen | |
24 // account picker as user pod custom icons. | |
25 // The id's should be kept in sync with values used by user_pod_row.js. | |
26 const char kLockedUserPodCustomIconId[] = "locked"; | |
27 const char kLockedToBeActivatedUserPodCustomIconId[] = "locked-to-be-activated"; | |
28 const char kLockedWithProximityHintUserPodCustomIconId[] = | |
29 "locked-with-proximity-hint"; | |
30 const char kUnlockedUserPodCustomIconId[] = "unlocked"; | |
31 const char kHardlockedUserPodCustomIconId[] = "hardlocked"; | |
32 const char kSpinnerUserPodCustomIconId[] = "spinner"; | |
33 | |
34 // Given the user pod icon, returns its id as used by the user pod UI code. | |
35 std::string GetIdForIcon(ScreenlockBridge::UserPodCustomIcon icon) { | |
36 switch (icon) { | |
37 case ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED: | |
38 return kLockedUserPodCustomIconId; | |
39 case ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED_TO_BE_ACTIVATED: | |
40 return kLockedToBeActivatedUserPodCustomIconId; | |
41 case ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED_WITH_PROXIMITY_HINT: | |
42 return kLockedWithProximityHintUserPodCustomIconId; | |
43 case ScreenlockBridge::USER_POD_CUSTOM_ICON_UNLOCKED: | |
44 return kUnlockedUserPodCustomIconId; | |
45 case ScreenlockBridge::USER_POD_CUSTOM_ICON_HARDLOCKED: | |
46 return kHardlockedUserPodCustomIconId; | |
47 case ScreenlockBridge::USER_POD_CUSTOM_ICON_SPINNER: | |
48 return kSpinnerUserPodCustomIconId; | |
49 default: | |
50 return ""; | |
51 } | |
52 } | |
53 | |
54 } // namespace | |
55 | |
56 // static | |
57 ScreenlockBridge* ScreenlockBridge::Get() { | |
58 return g_screenlock_bridge_bridge_instance.Pointer(); | |
59 } | |
60 | |
61 ScreenlockBridge::UserPodCustomIconOptions::UserPodCustomIconOptions() | |
62 : autoshow_tooltip_(false), | |
63 hardlock_on_click_(false), | |
64 is_trial_run_(false) { | |
65 } | |
66 | |
67 ScreenlockBridge::UserPodCustomIconOptions::~UserPodCustomIconOptions() {} | |
68 | |
69 scoped_ptr<base::DictionaryValue> | |
70 ScreenlockBridge::UserPodCustomIconOptions::ToDictionaryValue() const { | |
71 scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue()); | |
72 std::string icon_id = GetIdForIcon(icon_); | |
73 result->SetString("id", icon_id); | |
74 | |
75 if (!tooltip_.empty()) { | |
76 base::DictionaryValue* tooltip_options = new base::DictionaryValue(); | |
77 tooltip_options->SetString("text", tooltip_); | |
78 tooltip_options->SetBoolean("autoshow", autoshow_tooltip_); | |
79 result->Set("tooltip", tooltip_options); | |
80 } | |
81 | |
82 if (!aria_label_.empty()) | |
83 result->SetString("ariaLabel", aria_label_); | |
84 | |
85 if (hardlock_on_click_) | |
86 result->SetBoolean("hardlockOnClick", true); | |
87 | |
88 if (is_trial_run_) | |
89 result->SetBoolean("isTrialRun", true); | |
90 | |
91 return result.Pass(); | |
92 } | |
93 | |
94 void ScreenlockBridge::UserPodCustomIconOptions::SetIcon( | |
95 ScreenlockBridge::UserPodCustomIcon icon) { | |
96 icon_ = icon; | |
97 } | |
98 | |
99 void ScreenlockBridge::UserPodCustomIconOptions::SetTooltip( | |
100 const base::string16& tooltip, | |
101 bool autoshow) { | |
102 tooltip_ = tooltip; | |
103 autoshow_tooltip_ = autoshow; | |
104 } | |
105 | |
106 void ScreenlockBridge::UserPodCustomIconOptions::SetAriaLabel( | |
107 const base::string16& aria_label) { | |
108 aria_label_ = aria_label; | |
109 } | |
110 | |
111 void ScreenlockBridge::UserPodCustomIconOptions::SetHardlockOnClick() { | |
112 hardlock_on_click_ = true; | |
113 } | |
114 | |
115 void ScreenlockBridge::UserPodCustomIconOptions::SetTrialRun() { | |
116 is_trial_run_ = true; | |
117 } | |
118 | |
119 // static | |
120 std::string ScreenlockBridge::GetAuthenticatedUserEmail( | |
121 const Profile* profile) { | |
122 // |profile| has to be a signed-in profile with SigninManager already | |
123 // created. Otherwise, just crash to collect stack. | |
124 const SigninManagerBase* signin_manager = | |
125 SigninManagerFactory::GetForProfileIfExists(profile); | |
126 return signin_manager->GetAuthenticatedUsername(); | |
127 } | |
128 | |
129 ScreenlockBridge::ScreenlockBridge() : lock_handler_(NULL) { | |
130 } | |
131 | |
132 ScreenlockBridge::~ScreenlockBridge() { | |
133 } | |
134 | |
135 void ScreenlockBridge::SetLockHandler(LockHandler* lock_handler) { | |
136 DCHECK(lock_handler_ == NULL || lock_handler == NULL); | |
137 | |
138 // Don't notify observers if there is no change -- i.e. if the screen was | |
139 // already unlocked, and is remaining unlocked. | |
140 if (lock_handler == lock_handler_) | |
141 return; | |
142 | |
143 // TODO(isherman): If |lock_handler| is null, then |lock_handler_| might have | |
144 // been freed. Cache the screen type rather than querying it below. | |
145 LockHandler::ScreenType screen_type; | |
146 if (lock_handler_) | |
147 screen_type = lock_handler_->GetScreenType(); | |
148 else | |
149 screen_type = lock_handler->GetScreenType(); | |
150 | |
151 lock_handler_ = lock_handler; | |
152 if (lock_handler_) | |
153 FOR_EACH_OBSERVER(Observer, observers_, OnScreenDidLock(screen_type)); | |
154 else | |
155 FOR_EACH_OBSERVER(Observer, observers_, OnScreenDidUnlock(screen_type)); | |
156 } | |
157 | |
158 void ScreenlockBridge::SetFocusedUser(const std::string& user_id) { | |
159 if (user_id == focused_user_id_) | |
160 return; | |
161 focused_user_id_ = user_id; | |
162 FOR_EACH_OBSERVER(Observer, observers_, OnFocusedUserChanged(user_id)); | |
163 } | |
164 | |
165 bool ScreenlockBridge::IsLocked() const { | |
166 return lock_handler_ != NULL; | |
167 } | |
168 | |
169 void ScreenlockBridge::Lock(Profile* profile) { | |
170 #if defined(OS_CHROMEOS) | |
171 chromeos::SessionManagerClient* session_manager = | |
172 chromeos::DBusThreadManager::Get()->GetSessionManagerClient(); | |
173 session_manager->RequestLockScreen(); | |
174 #else | |
175 profiles::LockProfile(profile); | |
176 #endif | |
177 } | |
178 | |
179 void ScreenlockBridge::Unlock(Profile* profile) { | |
180 if (lock_handler_) | |
181 lock_handler_->Unlock(GetAuthenticatedUserEmail(profile)); | |
182 } | |
183 | |
184 void ScreenlockBridge::AddObserver(Observer* observer) { | |
185 observers_.AddObserver(observer); | |
186 } | |
187 | |
188 void ScreenlockBridge::RemoveObserver(Observer* observer) { | |
189 observers_.RemoveObserver(observer); | |
190 } | |
OLD | NEW |