Drive extension functions from ExtensionFunction::Run. The

chrome/browser/chromeos/extensions/screenlock_private_api.cc

 // Copyright 2013 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/chromeos/extensions/screenlock_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/extensions/image_loader.h"
@@ skipping 43 matching lines @@
       return screenlock::AUTH_TYPE_OFFLINEPASSWORD;
   }
 }
 
 }  // namespace
 
 ScreenlockPrivateGetLockedFunction::ScreenlockPrivateGetLockedFunction() {}
 
 ScreenlockPrivateGetLockedFunction::~ScreenlockPrivateGetLockedFunction() {}
 
-bool ScreenlockPrivateGetLockedFunction::RunImpl() {
+bool ScreenlockPrivateGetLockedFunction::RunAsync() {
   bool locked = false;
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (locker)
     locked = locker->locked();
   SetResult(new base::FundamentalValue(locked));
   SendResponse(error_.empty());
   return true;
 }
 
 ScreenlockPrivateSetLockedFunction::ScreenlockPrivateSetLockedFunction() {}
 
 ScreenlockPrivateSetLockedFunction::~ScreenlockPrivateSetLockedFunction() {}
 
-bool ScreenlockPrivateSetLockedFunction::RunImpl() {
+bool ScreenlockPrivateSetLockedFunction::RunAsync() {
   scoped_ptr<screenlock::SetLocked::Params> params(
       screenlock::SetLocked::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->locked) {
     chromeos::SessionManagerClient* session_manager =
         chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
     session_manager->RequestLockScreen();
   } else {
     chromeos::ScreenLocker* locker =
         chromeos::ScreenLocker::default_screen_locker();
     if (locker)
       chromeos::ScreenLocker::Hide();
   }
   SendResponse(error_.empty());
   return true;
 }
 
 ScreenlockPrivateShowMessageFunction::ScreenlockPrivateShowMessageFunction() {}
 
 ScreenlockPrivateShowMessageFunction::~ScreenlockPrivateShowMessageFunction() {}
 
-bool ScreenlockPrivateShowMessageFunction::RunImpl() {
+bool ScreenlockPrivateShowMessageFunction::RunAsync() {
   scoped_ptr<screenlock::ShowMessage::Params> params(
       screenlock::ShowMessage::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (locker)
     locker->ShowBannerMessage(params->message);
   SendResponse(error_.empty());
   return true;
 }
 
 static const int kMaxButtonIconSize = 40;
 
 ScreenlockPrivateShowButtonFunction::
   ScreenlockPrivateShowButtonFunction() {}
 
 ScreenlockPrivateShowButtonFunction::
   ~ScreenlockPrivateShowButtonFunction() {}
 
-bool ScreenlockPrivateShowButtonFunction::RunImpl() {
+bool ScreenlockPrivateShowButtonFunction::RunAsync() {
   scoped_ptr<screenlock::ShowButton::Params> params(
       screenlock::ShowButton::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (!locker) {
     SetError(kNotLockedError);
     SendResponse(false);
     return true;
   }
@@ skipping 18 matching lines @@
       image,
       base::Bind(&ScreenlockPrivateEventRouter::OnButtonClicked,
                  base::Unretained(router)));
   SendResponse(error_.empty());
 }
 
 ScreenlockPrivateHideButtonFunction::ScreenlockPrivateHideButtonFunction() {}
 
 ScreenlockPrivateHideButtonFunction::~ScreenlockPrivateHideButtonFunction() {}
 
-bool ScreenlockPrivateHideButtonFunction::RunImpl() {
+bool ScreenlockPrivateHideButtonFunction::RunAsync() {
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (locker) {
     const chromeos::User* user =
         chromeos::UserManager::Get()->GetUserByProfile(GetProfile());
     locker->HideUserPodButton(user->email());
   } else {
     SetError(kNotLockedError);
   }
   SendResponse(error_.empty());
   return true;
 }
 
 ScreenlockPrivateSetAuthTypeFunction::ScreenlockPrivateSetAuthTypeFunction() {}
 
 ScreenlockPrivateSetAuthTypeFunction::~ScreenlockPrivateSetAuthTypeFunction() {}
 
-bool ScreenlockPrivateSetAuthTypeFunction::RunImpl() {
+bool ScreenlockPrivateSetAuthTypeFunction::RunAsync() {
   scoped_ptr<screenlock::SetAuthType::Params> params(
       screenlock::SetAuthType::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (locker) {
     std::string initial_value =
         params->initial_value.get() ? *(params->initial_value.get()) : "";
     const chromeos::User* user =
         chromeos::UserManager::Get()->GetUserByProfile(GetProfile());
     locker->SetAuthType(user->email(),
                         ToLoginDisplayAuthType(params->auth_type),
                         initial_value);
   } else {
     SetError(kNotLockedError);
   }
   SendResponse(error_.empty());
   return true;
 }
 
 ScreenlockPrivateGetAuthTypeFunction::ScreenlockPrivateGetAuthTypeFunction() {}
 
 ScreenlockPrivateGetAuthTypeFunction::~ScreenlockPrivateGetAuthTypeFunction() {}
 
-bool ScreenlockPrivateGetAuthTypeFunction::RunImpl() {
+bool ScreenlockPrivateGetAuthTypeFunction::RunAsync() {
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (locker) {
     const chromeos::User* user =
         chromeos::UserManager::Get()->GetUserByProfile(GetProfile());
     chromeos::LoginDisplay::AuthType auth_type =
         locker->GetAuthType(user->email());
     std::string auth_type_name =
         screenlock::ToString(ToScreenlockPrivateAuthType(auth_type));
     SetResult(new base::StringValue(auth_type_name));
   } else {
     SetError(kNotLockedError);
   }
   SendResponse(error_.empty());
   return true;
 }
 
 ScreenlockPrivateAcceptAuthAttemptFunction::
     ScreenlockPrivateAcceptAuthAttemptFunction() {}
 
 ScreenlockPrivateAcceptAuthAttemptFunction::
     ~ScreenlockPrivateAcceptAuthAttemptFunction() {}
 
-bool ScreenlockPrivateAcceptAuthAttemptFunction::RunImpl() {
+bool ScreenlockPrivateAcceptAuthAttemptFunction::RunAsync() {
   scoped_ptr<screenlock::AcceptAuthAttempt::Params> params(
       screenlock::AcceptAuthAttempt::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   chromeos::ScreenLocker* locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (locker) {
     if (params->accept)
       chromeos::ScreenLocker::Hide();
     else
@@ skipping 64 matching lines @@
   args->AppendString(
       screenlock::ToString(ToScreenlockPrivateAuthType(auth_type)));
   args->AppendString(value);
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       screenlock::OnAuthAttempted::kEventName, args.Pass()));
   extensions::EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
 }  // namespace extensions