Abandon user sign in when policy is retrieved before session started

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 211 matching lines @@
     return policy;
   }
 
   void RetrievePolicyForUser(const cryptohome::Identification& cryptohome_id,
                              const RetrievePolicyCallback& callback) override {
     CallRetrievePolicyByUsername(
         login_manager::kSessionManagerRetrievePolicyForUser, cryptohome_id.id(),
         callback);
   }
 
+  void RetrievePolicyForUserWithErrorCallback(
+      const cryptohome::Identification& cryptohome_id,
+      const RetrievePolicyCallback& callback,
+      const ErrorCallback& error_callback) override {
+    CallRetrievePolicyByUsernameWithErrorCallback(
+        login_manager::kSessionManagerRetrievePolicyForUser, cryptohome_id.id(),
+        callback, error_callback);
+  }
+
   std::string BlockingRetrievePolicyForUser(
       const cryptohome::Identification& cryptohome_id) override {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
         login_manager::kSessionManagerRetrievePolicyForUser);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(cryptohome_id.id());
     std::unique_ptr<dbus::Response> response =
         blocking_method_caller_->CallMethodAndBlock(&method_call);
     std::string policy;
@@ skipping 256 matching lines @@
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &SessionManagerClientImpl::OnRetrievePolicy,
             weak_ptr_factory_.GetWeakPtr(),
             method_name,
             callback));
   }
 
+  void CallRetrievePolicyByUsernameWithErrorCallback(
+      const std::string& method_name,
+      const std::string& account_id,
+      const RetrievePolicyCallback& callback,
+      const ErrorCallback& error_callback) {
+    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
+                                 method_name);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(account_id);

[Daniel Erat, 2017/04/10 18:59:26]

please avoid copy-and-pasting code (i.e. the existing method is almost exactly
the same)

[igorcov, 2017/04/18 10:23:18]

Done.

+    session_manager_proxy_->CallMethodWithErrorCallback(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&SessionManagerClientImpl::OnRetrievePolicy,
+                   weak_ptr_factory_.GetWeakPtr(), method_name, callback),
+        base::Bind(&SessionManagerClientImpl::OnRetrievePolicyWithError,
+                   weak_ptr_factory_.GetWeakPtr(), error_callback));
+  }
+
   void CallStorePolicyByUsername(const std::string& method_name,
                                  const std::string& account_id,
                                  const std::string& policy_blob,
                                  const StorePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(account_id);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
@@ skipping 98 matching lines @@
   // Called when kSessionManagerRetrievePolicy or
   // kSessionManagerRetrievePolicyForUser method is complete.
   void OnRetrievePolicy(const std::string& method_name,
                         const RetrievePolicyCallback& callback,
                         dbus::Response* response) {
     std::string serialized_proto;
     ExtractString(method_name, response, &serialized_proto);
     callback.Run(serialized_proto);
   }
 
+  void OnRetrievePolicyWithError(const ErrorCallback& callback,
+                                 dbus::ErrorResponse* response) {
+    std::string error_name;
+    std::string error_message;
+    dbus::MessageReader reader(response);
+    error_name = response->GetErrorName();
+    reader.PopString(&error_message);
+    callback.Run(error_name, error_message);
+  }
+
   // Called when kSessionManagerStorePolicy or kSessionManagerStorePolicyForUser
   // method is complete.
   void OnStorePolicy(const std::string& method_name,
                      const StorePolicyCallback& callback,
                      dbus::Response* response) {
     bool success = false;
     if (!response) {
       LOG(ERROR) << "Failed to call " << method_name;
     } else {
       dbus::MessageReader reader(response);
@@ skipping 251 matching lines @@
     base::PostTaskWithTraitsAndReplyWithResult(
         FROM_HERE,
         base::TaskTraits()
             .WithShutdownBehavior(
                 base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
             .MayBlock(),
         base::Bind(&GetFileContent,
                    GetUserFilePath(cryptohome_id, kStubPolicyFile)),
         callback);
   }
+  void RetrievePolicyForUserWithErrorCallback(
+      const cryptohome::Identification& cryptohome_id,
+      const RetrievePolicyCallback& callback,
+      const ErrorCallback& error_callback) override {
+    RetrievePolicyForUser(cryptohome_id, callback);
+  }
   std::string BlockingRetrievePolicyForUser(
       const cryptohome::Identification& cryptohome_id) override {
     return GetFileContent(GetUserFilePath(cryptohome_id, kStubPolicyFile));
   }
   void RetrieveDeviceLocalAccountPolicy(
       const std::string& account_id,
       const RetrievePolicyCallback& callback) override {
     RetrievePolicyForUser(cryptohome::Identification::FromString(account_id),
                           callback);
   }
@@ skipping 146 matching lines @@
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos