Remove calls to deprecated session_manager DBus methods

chromeos/dbus/session_manager_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/session_manager_client.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 53 matching lines @@
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(pid);
     writer.AppendString(command_line);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnRestartJob,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual void RestartEntd() OVERRIDE {
-    SimpleMethodCallToSessionManager(login_manager::kSessionManagerRestartEntd);
-  }
-
   virtual void StartSession(const std::string& user_email) OVERRIDE {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStartSession);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(user_email);
     writer.AppendString("");  // Unique ID is deprecated
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStartSession,
@@ skipping 24 matching lines @@
 
   virtual void RequestLockScreen() OVERRIDE {
     SimpleMethodCallToSessionManager(login_manager::kSessionManagerLockScreen);
   }
 
   virtual void NotifyLockScreenShown() OVERRIDE {
     SimpleMethodCallToSessionManager(
         login_manager::kSessionManagerHandleLockScreenShown);
   }
 
-  virtual void RequestUnlockScreen() OVERRIDE {
-    SimpleMethodCallToSessionManager(
-        login_manager::kSessionManagerUnlockScreen);
-  }
-
   virtual void NotifyLockScreenDismissed() OVERRIDE {
     SimpleMethodCallToSessionManager(
         login_manager::kSessionManagerHandleLockScreenDismissed);
   }
 
   virtual void RetrieveActiveSessions(
       const ActiveSessionsCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
         login_manager::kSessionManagerRetrieveActiveSessions);
@@ skipping 132 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()));
     session_manager_proxy_->ConnectToSignal(
         chromium::kChromiumInterface,
         chromium::kLockScreenSignal,
         base::Bind(&SessionManagerClientImpl::ScreenLockReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&SessionManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
     session_manager_proxy_->ConnectToSignal(
         chromium::kChromiumInterface,
-        chromium::kUnlockScreenSignal,
-        base::Bind(&SessionManagerClientImpl::ScreenUnlockReceived,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&SessionManagerClientImpl::SignalConnected,
-                   weak_ptr_factory_.GetWeakPtr()));
-    session_manager_proxy_->ConnectToSignal(
-        chromium::kChromiumInterface,
         chromium::kLivenessRequestedSignal,
         base::Bind(&SessionManagerClientImpl::LivenessRequestedReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&SessionManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
     // Signals emitted on the session manager's interface.
     session_manager_proxy_->ConnectToSignal(
         login_manager::kSessionManagerInterface,
         login_manager::kScreenIsLockedSignal,
@@ skipping 191 matching lines @@
       return;
     }
     const bool success = StartsWithASCII(result_string, "success", false);
     FOR_EACH_OBSERVER(Observer, observers_, PropertyChangeComplete(success));
   }
 
   void ScreenLockReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, LockScreen());
   }
 
-  void ScreenUnlockReceived(dbus::Signal* signal) {
-    FOR_EACH_OBSERVER(Observer, observers_, UnlockScreen());
-  }
-
   void LivenessRequestedReceived(dbus::Signal* signal) {
     SimpleMethodCallToSessionManager(
         login_manager::kSessionManagerHandleLivenessConfirmed);
   }
 
   void ScreenIsLockedReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
   }
 
   void ScreenIsUnlockedReceived(dbus::Signal* signal) {
@@ skipping 44 matching lines @@
   }
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
   virtual bool HasObserver(Observer* observer) OVERRIDE {
     return observers_.HasObserver(observer);
   }
   virtual void EmitLoginPromptReady() OVERRIDE {}
   virtual void EmitLoginPromptVisible() OVERRIDE {}
   virtual void RestartJob(int pid, const std::string& command_line) OVERRIDE {}
-  virtual void RestartEntd() OVERRIDE {}
   virtual void StartSession(const std::string& user_email) OVERRIDE {}
   virtual void StopSession() OVERRIDE {}
   virtual void StartDeviceWipe() OVERRIDE {}
   virtual void RequestLockScreen() OVERRIDE {
     FOR_EACH_OBSERVER(Observer, observers_, LockScreen());
   }
   virtual void NotifyLockScreenShown() OVERRIDE {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
   }
-  virtual void RequestUnlockScreen() OVERRIDE {
-    FOR_EACH_OBSERVER(Observer, observers_, UnlockScreen());
-  }
   virtual void NotifyLockScreenDismissed() OVERRIDE {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
   }
   virtual void RetrieveActiveSessions(
       const ActiveSessionsCallback& callback) OVERRIDE {}
   virtual void RetrieveDevicePolicy(
       const RetrievePolicyCallback& callback) OVERRIDE {
     callback.Run(device_policy_);
   }
   virtual void RetrievePolicyForUser(
@@ skipping 85 matching lines @@
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos