chromeos: Remove old LockScreen signal.

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 18 matching lines @@
 class SessionManagerClientImpl : public SessionManagerClient {
  public:
   SessionManagerClientImpl()
       : session_manager_proxy_(NULL),
         weak_ptr_factory_(this) {}
 
   virtual ~SessionManagerClientImpl() {
   }
 
   // SessionManagerClient overrides:
+  virtual void SetStubDelegate(StubDelegate* delegate) OVERRIDE {
+    // Do nothing; this isn't a stub implementation.
+  }
+
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
   virtual bool HasObserver(Observer* observer) OVERRIDE {
     return observers_.HasObserver(observer);
@@ skipping 182 matching lines @@
   }
 
  protected:
   virtual void Init(dbus::Bus* bus) OVERRIDE {
     session_manager_proxy_ = bus->GetObjectProxy(
         login_manager::kSessionManagerServiceName,
         dbus::ObjectPath(login_manager::kSessionManagerServicePath));
     blocking_method_caller_.reset(
         new BlockingMethodCaller(bus, session_manager_proxy_));
 
-    // Signals emitted on Chromium's interface.  Many of these ought to be
-    // method calls instead.
-    session_manager_proxy_->ConnectToSignal(
-        chromium::kChromiumInterface,
-        chromium::kLockScreenSignal,
-        base::Bind(&SessionManagerClientImpl::ScreenLockReceived,
-                   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::kOwnerKeySetSignal,
         base::Bind(&SessionManagerClientImpl::OwnerKeySetReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&SessionManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
     session_manager_proxy_->ConnectToSignal(
         login_manager::kSessionManagerInterface,
@@ skipping 195 matching lines @@
     dbus::MessageReader reader(signal);
     std::string result_string;
     if (!reader.PopString(&result_string)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       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 ScreenIsLockedReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
   }
 
   void ScreenIsUnlockedReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
   }
 
   // Called when the object is connected to the signal.
   void SignalConnected(const std::string& interface_name,
@@ skipping 10 matching lines @@
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<SessionManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionManagerClientImpl);
 };
 
 // The SessionManagerClient implementation used on Linux desktop,
 // which does nothing.
 class SessionManagerClientStubImpl : public SessionManagerClient {
  public:
-  SessionManagerClientStubImpl() {}
+  SessionManagerClientStubImpl() : delegate_(NULL) {}
   virtual ~SessionManagerClientStubImpl() {}
 
   // SessionManagerClient overrides
   virtual void Init(dbus::Bus* bus) OVERRIDE {
     // Make sure that there are no keys left over from a previous browser run.
     base::FilePath user_policy_key_dir;
     if (PathService::Get(chromeos::DIR_USER_POLICY_KEYS,
                          &user_policy_key_dir)) {
       base::WorkerPool::PostTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(&base::DeleteFile),
                      user_policy_key_dir, true),
           false);
     }
   }
 
+  virtual void SetStubDelegate(StubDelegate* delegate) OVERRIDE {
+    delegate_ = delegate;
+  }
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
   virtual bool HasObserver(Observer* observer) OVERRIDE {
     return observers_.HasObserver(observer);
   }
   virtual void EmitLoginPromptVisible() OVERRIDE {}
   virtual void RestartJob(int pid, const std::string& command_line) 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());
+    if (delegate_)
+      delegate_->LockScreenForStub();
   }
   virtual void NotifyLockScreenShown() OVERRIDE {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
   }
   virtual void NotifyLockScreenDismissed() OVERRIDE {
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
   }
   virtual void RetrieveActiveSessions(
       const ActiveSessionsCallback& callback) OVERRIDE {}
   virtual void RetrieveDevicePolicy(
@@ skipping 67 matching lines @@
   static void StoreFileInBackground(const base::FilePath& path,
                                     const std::string& data) {
     const int size = static_cast<int>(data.size());
     if (!base::CreateDirectory(path.DirName()) ||
         base::WriteFile(path, data.data(), size) != size) {
       LOG(WARNING) << "Failed to write policy key to " << path.value();
     }
   }
 
  private:
+  StubDelegate* delegate_;  // Weak pointer; may be NULL.
   ObserverList<Observer> observers_;
   std::string device_policy_;
   std::map<std::string, std::string> user_policies_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionManagerClientStubImpl);
 };
 
 SessionManagerClient::SessionManagerClient() {
 }
 
 SessionManagerClient::~SessionManagerClient() {
 }
 
 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