[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 1 | // Copyright 2013 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 "ash/display/resolution_notification_controller.h" |
| 6 | |
dcheng | 2272495 | 2015-12-31 03:17:54 | [diff] [blame] | 7 | #include <utility> |
| 8 | |
msw | 7f1ec92 | 2016-06-22 23:58:56 | [diff] [blame] | 9 | #include "ash/common/display/display_info.h" |
msw | 6a94e049 | 2016-06-17 17:21:38 | [diff] [blame] | 10 | #include "ash/common/system/system_notifier.h" |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 11 | #include "ash/display/display_manager.h" |
| 12 | #include "ash/shell.h" |
| 13 | #include "base/strings/utf_string_conversions.h" |
| 14 | #include "grit/ash_resources.h" |
| 15 | #include "grit/ash_strings.h" |
| 16 | #include "ui/base/l10n/l10n_util.h" |
| 17 | #include "ui/base/l10n/time_format.h" |
| 18 | #include "ui/base/resource/resource_bundle.h" |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 19 | #include "ui/display/display.h" |
| 20 | #include "ui/display/screen.h" |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 21 | #include "ui/message_center/message_center.h" |
| 22 | #include "ui/message_center/notification.h" |
| 23 | #include "ui/message_center/notification_delegate.h" |
| 24 | |
| 25 | using message_center::Notification; |
| 26 | |
| 27 | namespace ash { |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 28 | namespace { |
| 29 | |
| 30 | bool g_use_timer = true; |
| 31 | |
| 32 | class ResolutionChangeNotificationDelegate |
| 33 | : public message_center::NotificationDelegate { |
| 34 | public: |
| 35 | ResolutionChangeNotificationDelegate( |
| 36 | ResolutionNotificationController* controller, |
| 37 | bool has_timeout); |
| 38 | |
| 39 | protected: |
dcheng | 222b9c7 | 2015-01-16 00:48:01 | [diff] [blame] | 40 | ~ResolutionChangeNotificationDelegate() override; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 41 | |
| 42 | private: |
| 43 | // message_center::NotificationDelegate overrides: |
dcheng | 222b9c7 | 2015-01-16 00:48:01 | [diff] [blame] | 44 | void Close(bool by_user) override; |
| 45 | void Click() override; |
| 46 | bool HasClickedListener() override; |
| 47 | void ButtonClick(int button_index) override; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 48 | |
| 49 | ResolutionNotificationController* controller_; |
| 50 | bool has_timeout_; |
| 51 | |
| 52 | DISALLOW_COPY_AND_ASSIGN(ResolutionChangeNotificationDelegate); |
| 53 | }; |
| 54 | |
| 55 | ResolutionChangeNotificationDelegate::ResolutionChangeNotificationDelegate( |
| 56 | ResolutionNotificationController* controller, |
| 57 | bool has_timeout) |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 58 | : controller_(controller), has_timeout_(has_timeout) { |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 59 | DCHECK(controller_); |
| 60 | } |
| 61 | |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 62 | ResolutionChangeNotificationDelegate::~ResolutionChangeNotificationDelegate() {} |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 63 | |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 64 | void ResolutionChangeNotificationDelegate::Close(bool by_user) { |
| 65 | if (by_user) |
[email protected] | 99e487e | 2013-08-13 20:58:41 | [diff] [blame] | 66 | controller_->AcceptResolutionChange(false); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | void ResolutionChangeNotificationDelegate::Click() { |
[email protected] | 99e487e | 2013-08-13 20:58:41 | [diff] [blame] | 70 | controller_->AcceptResolutionChange(true); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | bool ResolutionChangeNotificationDelegate::HasClickedListener() { |
| 74 | return true; |
| 75 | } |
| 76 | |
| 77 | void ResolutionChangeNotificationDelegate::ButtonClick(int button_index) { |
| 78 | // If there's the timeout, the first button is "Accept". Otherwise the |
| 79 | // button click should be "Revert". |
| 80 | if (has_timeout_ && button_index == 0) |
[email protected] | 99e487e | 2013-08-13 20:58:41 | [diff] [blame] | 81 | controller_->AcceptResolutionChange(true); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 82 | else |
| 83 | controller_->RevertResolutionChange(); |
| 84 | } |
| 85 | |
| 86 | } // namespace |
| 87 | |
| 88 | // static |
| 89 | const int ResolutionNotificationController::kTimeoutInSec = 15; |
| 90 | |
| 91 | // static |
| 92 | const char ResolutionNotificationController::kNotificationId[] = |
| 93 | "chrome://settings/display/resolution"; |
| 94 | |
| 95 | struct ResolutionNotificationController::ResolutionChangeInfo { |
avi | db567a8a | 2015-12-20 17:07:24 | [diff] [blame] | 96 | ResolutionChangeInfo(int64_t display_id, |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 97 | const DisplayMode& old_resolution, |
| 98 | const DisplayMode& new_resolution, |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 99 | const base::Closure& accept_callback); |
| 100 | ~ResolutionChangeInfo(); |
| 101 | |
| 102 | // The id of the display where the resolution change happens. |
avi | db567a8a | 2015-12-20 17:07:24 | [diff] [blame] | 103 | int64_t display_id; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 104 | |
| 105 | // The resolution before the change. |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 106 | DisplayMode old_resolution; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 107 | |
[email protected] | c91bd6c | 2014-01-22 11:51:10 | [diff] [blame] | 108 | // The requested resolution. Note that this may be different from |
| 109 | // |current_resolution| which is the actual resolution set. |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 110 | DisplayMode new_resolution; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 111 | |
[email protected] | c91bd6c | 2014-01-22 11:51:10 | [diff] [blame] | 112 | // The actual resolution after the change. |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 113 | DisplayMode current_resolution; |
[email protected] | c91bd6c | 2014-01-22 11:51:10 | [diff] [blame] | 114 | |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 115 | // The callback when accept is chosen. |
| 116 | base::Closure accept_callback; |
| 117 | |
| 118 | // The remaining timeout in seconds. 0 if the change does not time out. |
avi | db567a8a | 2015-12-20 17:07:24 | [diff] [blame] | 119 | uint8_t timeout_count; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 120 | |
| 121 | // The timer to invoke OnTimerTick() every second. This cannot be |
| 122 | // OneShotTimer since the message contains text "automatically closed in xx |
| 123 | // seconds..." which has to be updated every second. |
danakj | 8c3eb80 | 2015-09-24 07:53:00 | [diff] [blame] | 124 | base::RepeatingTimer timer; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 125 | |
| 126 | private: |
| 127 | DISALLOW_COPY_AND_ASSIGN(ResolutionChangeInfo); |
| 128 | }; |
| 129 | |
| 130 | ResolutionNotificationController::ResolutionChangeInfo::ResolutionChangeInfo( |
avi | db567a8a | 2015-12-20 17:07:24 | [diff] [blame] | 131 | int64_t display_id, |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 132 | const DisplayMode& old_resolution, |
| 133 | const DisplayMode& new_resolution, |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 134 | const base::Closure& accept_callback) |
| 135 | : display_id(display_id), |
| 136 | old_resolution(old_resolution), |
| 137 | new_resolution(new_resolution), |
| 138 | accept_callback(accept_callback), |
| 139 | timeout_count(0) { |
| 140 | DisplayManager* display_manager = Shell::GetInstance()->display_manager(); |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 141 | if (!display::Display::HasInternalDisplay() && |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 142 | display_manager->num_connected_displays() == 1u) { |
| 143 | timeout_count = kTimeoutInSec; |
| 144 | } |
| 145 | } |
| 146 | |
| 147 | ResolutionNotificationController::ResolutionChangeInfo:: |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 148 | ~ResolutionChangeInfo() {} |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 149 | |
| 150 | ResolutionNotificationController::ResolutionNotificationController() { |
oshima | e281892 | 2015-07-28 01:18:52 | [diff] [blame] | 151 | Shell::GetInstance()->window_tree_host_manager()->AddObserver(this); |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 152 | display::Screen::GetScreen()->AddObserver(this); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | ResolutionNotificationController::~ResolutionNotificationController() { |
oshima | e281892 | 2015-07-28 01:18:52 | [diff] [blame] | 156 | Shell::GetInstance()->window_tree_host_manager()->RemoveObserver(this); |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 157 | display::Screen::GetScreen()->RemoveObserver(this); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 158 | } |
| 159 | |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 160 | void ResolutionNotificationController::PrepareNotification( |
avi | db567a8a | 2015-12-20 17:07:24 | [diff] [blame] | 161 | int64_t display_id, |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 162 | const DisplayMode& old_resolution, |
| 163 | const DisplayMode& new_resolution, |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 164 | const base::Closure& accept_callback) { |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 165 | DCHECK(!display::Display::IsInternalDisplayId(display_id)); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 166 | // If multiple resolution changes are invoked for the same display, |
| 167 | // the original resolution for the first resolution change has to be used |
| 168 | // instead of the specified |old_resolution|. |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 169 | DisplayMode original_resolution; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 170 | if (change_info_ && change_info_->display_id == display_id) { |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 171 | DCHECK(change_info_->new_resolution.size == old_resolution.size); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 172 | original_resolution = change_info_->old_resolution; |
| 173 | } |
| 174 | |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 175 | change_info_.reset(new ResolutionChangeInfo(display_id, old_resolution, |
| 176 | new_resolution, accept_callback)); |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 177 | if (!original_resolution.size.IsEmpty()) |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 178 | change_info_->old_resolution = original_resolution; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | bool ResolutionNotificationController::DoesNotificationTimeout() { |
| 182 | return change_info_ && change_info_->timeout_count > 0; |
| 183 | } |
| 184 | |
[email protected] | 86eee6e | 2013-08-27 01:27:15 | [diff] [blame] | 185 | void ResolutionNotificationController::CreateOrUpdateNotification( |
| 186 | bool enable_spoken_feedback) { |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 187 | message_center::MessageCenter* message_center = |
| 188 | message_center::MessageCenter::Get(); |
| 189 | if (!change_info_) { |
| 190 | message_center->RemoveNotification(kNotificationId, false /* by_user */); |
| 191 | return; |
| 192 | } |
| 193 | |
| 194 | base::string16 timeout_message; |
| 195 | message_center::RichNotificationData data; |
| 196 | if (change_info_->timeout_count > 0) { |
| 197 | data.buttons.push_back(message_center::ButtonInfo( |
| 198 | l10n_util::GetStringUTF16(IDS_ASH_DISPLAY_RESOLUTION_CHANGE_ACCEPT))); |
| 199 | timeout_message = l10n_util::GetStringFUTF16( |
| 200 | IDS_ASH_DISPLAY_RESOLUTION_TIMEOUT, |
[email protected] | b6cc963b | 2014-02-27 15:32:23 | [diff] [blame] | 201 | ui::TimeFormat::Simple( |
| 202 | ui::TimeFormat::FORMAT_DURATION, ui::TimeFormat::LENGTH_LONG, |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 203 | base::TimeDelta::FromSeconds(change_info_->timeout_count))); |
| 204 | } |
| 205 | data.buttons.push_back(message_center::ButtonInfo( |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 206 | l10n_util::GetStringUTF16(IDS_ASH_DISPLAY_RESOLUTION_CHANGE_REVERT))); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 207 | |
[email protected] | 86eee6e | 2013-08-27 01:27:15 | [diff] [blame] | 208 | data.should_make_spoken_feedback_for_popup_updates = enable_spoken_feedback; |
| 209 | |
[email protected] | c91bd6c | 2014-01-22 11:51:10 | [diff] [blame] | 210 | const base::string16 display_name = base::UTF8ToUTF16( |
| 211 | Shell::GetInstance()->display_manager()->GetDisplayNameForId( |
| 212 | change_info_->display_id)); |
| 213 | const base::string16 message = |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 214 | (change_info_->new_resolution.size == |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 215 | change_info_->current_resolution.size) |
| 216 | ? l10n_util::GetStringFUTF16( |
| 217 | IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED, display_name, |
| 218 | base::UTF8ToUTF16(change_info_->new_resolution.size.ToString())) |
| 219 | : l10n_util::GetStringFUTF16( |
| 220 | IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED_TO_UNSUPPORTED, |
| 221 | display_name, |
| 222 | base::UTF8ToUTF16(change_info_->new_resolution.size.ToString()), |
| 223 | base::UTF8ToUTF16( |
| 224 | change_info_->current_resolution.size.ToString())); |
[email protected] | c91bd6c | 2014-01-22 11:51:10 | [diff] [blame] | 225 | |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 226 | ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance(); |
dcheng | a9454747 | 2016-04-08 08:41:11 | [diff] [blame] | 227 | std::unique_ptr<Notification> notification(new Notification( |
miguelg | 53a6dde5 | 2015-08-20 09:00:30 | [diff] [blame] | 228 | message_center::NOTIFICATION_TYPE_SIMPLE, kNotificationId, message, |
| 229 | timeout_message, bundle.GetImageNamed(IDR_AURA_NOTIFICATION_DISPLAY), |
| 230 | base::string16() /* display_source */, GURL(), |
[email protected] | b78d79a5 | 2013-09-12 01:52:21 | [diff] [blame] | 231 | message_center::NotifierId( |
[email protected] | de22ffea | 2013-12-07 03:34:29 | [diff] [blame] | 232 | message_center::NotifierId::SYSTEM_COMPONENT, |
| 233 | system_notifier::kNotifierDisplayResolutionChange), |
miguelg | 53a6dde5 | 2015-08-20 09:00:30 | [diff] [blame] | 234 | data, new ResolutionChangeNotificationDelegate( |
| 235 | this, change_info_->timeout_count > 0))); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 236 | notification->SetSystemPriority(); |
dcheng | 2272495 | 2015-12-31 03:17:54 | [diff] [blame] | 237 | message_center->AddNotification(std::move(notification)); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | void ResolutionNotificationController::OnTimerTick() { |
| 241 | if (!change_info_) |
| 242 | return; |
| 243 | |
| 244 | --change_info_->timeout_count; |
| 245 | if (change_info_->timeout_count == 0) |
| 246 | RevertResolutionChange(); |
| 247 | else |
[email protected] | 86eee6e | 2013-08-27 01:27:15 | [diff] [blame] | 248 | CreateOrUpdateNotification(false); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 249 | } |
| 250 | |
[email protected] | 99e487e | 2013-08-13 20:58:41 | [diff] [blame] | 251 | void ResolutionNotificationController::AcceptResolutionChange( |
| 252 | bool close_notification) { |
| 253 | if (close_notification) { |
| 254 | message_center::MessageCenter::Get()->RemoveNotification( |
| 255 | kNotificationId, false /* by_user */); |
| 256 | } |
oshima | 8f0f45e4 | 2015-04-03 19:55:22 | [diff] [blame] | 257 | if (!change_info_) |
| 258 | return; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 259 | base::Closure callback = change_info_->accept_callback; |
| 260 | change_info_.reset(); |
| 261 | callback.Run(); |
| 262 | } |
| 263 | |
| 264 | void ResolutionNotificationController::RevertResolutionChange() { |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 265 | message_center::MessageCenter::Get()->RemoveNotification(kNotificationId, |
| 266 | false /* by_user */); |
oshima | 8f0f45e4 | 2015-04-03 19:55:22 | [diff] [blame] | 267 | if (!change_info_) |
| 268 | return; |
avi | db567a8a | 2015-12-20 17:07:24 | [diff] [blame] | 269 | int64_t display_id = change_info_->display_id; |
[email protected] | 7badf7f | 2014-08-06 04:38:29 | [diff] [blame] | 270 | DisplayMode old_resolution = change_info_->old_resolution; |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 271 | change_info_.reset(); |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 272 | Shell::GetInstance()->display_manager()->SetDisplayMode(display_id, |
| 273 | old_resolution); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 274 | } |
| 275 | |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 276 | void ResolutionNotificationController::OnDisplayAdded( |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 277 | const display::Display& new_display) {} |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 278 | |
| 279 | void ResolutionNotificationController::OnDisplayRemoved( |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 280 | const display::Display& old_display) { |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 281 | if (change_info_ && change_info_->display_id == old_display.id()) |
| 282 | RevertResolutionChange(); |
| 283 | } |
| 284 | |
[email protected] | 0c5703d | 2014-05-22 01:26:01 | [diff] [blame] | 285 | void ResolutionNotificationController::OnDisplayMetricsChanged( |
oshima | f84b0da72 | 2016-04-27 19:47:19 | [diff] [blame] | 286 | const display::Display&, |
| 287 | uint32_t) {} |
[email protected] | 0c5703d | 2014-05-22 01:26:01 | [diff] [blame] | 288 | |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 289 | void ResolutionNotificationController::OnDisplayConfigurationChanged() { |
| 290 | if (!change_info_) |
| 291 | return; |
| 292 | |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 293 | change_info_->current_resolution = |
| 294 | Shell::GetInstance()->display_manager()->GetActiveModeForDisplayId( |
| 295 | change_info_->display_id); |
[email protected] | 86eee6e | 2013-08-27 01:27:15 | [diff] [blame] | 296 | CreateOrUpdateNotification(true); |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 297 | if (g_use_timer && change_info_->timeout_count > 0) { |
jamescook | b8dcef52 | 2016-06-25 14:42:55 | [diff] [blame] | 298 | change_info_->timer.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this, |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 299 | &ResolutionNotificationController::OnTimerTick); |
| 300 | } |
| 301 | } |
| 302 | |
| 303 | void ResolutionNotificationController::SuppressTimerForTest() { |
| 304 | g_use_timer = false; |
| 305 | } |
| 306 | |
[email protected] | 6ef71d7 | 2013-08-10 18:13:44 | [diff] [blame] | 307 | } // namespace ash |