chromeos: Make CheckIdleStateIsLocked() query D-Bus client.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 48 matching lines @@
   }
 }
 
 }  // namespace
 
 // The SessionManagerClient implementation used in production.
 class SessionManagerClientImpl : public SessionManagerClient {
  public:
   SessionManagerClientImpl()
       : session_manager_proxy_(NULL),
+        screen_is_locked_(false),
         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(const Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
 
+  virtual bool IsScreenLocked() const override { return screen_is_locked_; }
+
   virtual void EmitLoginPromptVisible() override {
     SimpleMethodCallToSessionManager(
         login_manager::kSessionManagerEmitLoginPromptVisible);
     FOR_EACH_OBSERVER(Observer, observers_, EmitLoginPromptVisibleCalled());
   }
 
   virtual void RestartJob(int pid, const std::string& command_line) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerRestartJob);
     dbus::MessageWriter writer(&method_call);
@@ skipping 409 matching lines @@
     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 ScreenIsLockedReceived(dbus::Signal* signal) {
+    screen_is_locked_ = true;
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
   }
 
   void ScreenIsUnlockedReceived(dbus::Signal* signal) {
+    screen_is_locked_ = false;
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
   }
 
   // Called when the object is connected to the signal.
   void SignalConnected(const std::string& interface_name,
                        const std::string& signal_name,
                        bool success) {
     LOG_IF(ERROR, !success) << "Failed to connect to " << signal_name;
   }
 
@@ skipping 27 matching lines @@
 
     if (!callback.is_null())
       callback.Run(state_keys);
   }
 
 
   dbus::ObjectProxy* session_manager_proxy_;
   scoped_ptr<BlockingMethodCaller> blocking_method_caller_;
   ObserverList<Observer> observers_;
 
+  // Most recent screen-lock state received from session_manager.
+  bool screen_is_locked_;
+
   // Note: This should remain the last member so it'll be destroyed and
   // 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() : delegate_(NULL) {}
+  SessionManagerClientStubImpl() : delegate_(NULL), screen_is_locked_(false) {}
   virtual ~SessionManagerClientStubImpl() {}
 
   // SessionManagerClient overrides
   virtual void Init(dbus::Bus* bus) override {}
   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(const Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
+  virtual bool IsScreenLocked() const override { return screen_is_locked_; }
   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 NotifySupervisedUserCreationStarted() override {}
   virtual void NotifySupervisedUserCreationFinished() override {}
   virtual void StartDeviceWipe() override {}
   virtual void RequestLockScreen() override {
     if (delegate_)
       delegate_->LockScreenForStub();
   }
   virtual void NotifyLockScreenShown() override {
+    screen_is_locked_ = true;
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
   }
   virtual void NotifyLockScreenDismissed() override {
+    screen_is_locked_ = false;
     FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
   }
   virtual void RetrieveActiveSessions(
       const ActiveSessionsCallback& callback) override {}
   virtual void RetrieveDevicePolicy(
       const RetrievePolicyCallback& callback) override {
     base::FilePath owner_key_path;
     if (!PathService::Get(chromeos::FILE_OWNER_KEY, &owner_key_path)) {
       callback.Run("");
       return;
@@ skipping 101 matching lines @@
       state_keys.push_back(crypto::SHA256HashString(base::IntToString(i)));
 
     if (!callback.is_null())
       callback.Run(state_keys);
   }
 
  private:
   StubDelegate* delegate_;  // Weak pointer; may be NULL.
   ObserverList<Observer> observers_;
   std::string device_policy_;
+  bool screen_is_locked_;
 
   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