chromeos: Change all clients of LoginLibrary to use SessionManagerClient.

chrome/browser/chromeos/login/signed_settings.cc

 // Copyright (c) 2011 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/login/signed_settings.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/login_library.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
+#include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
+#include "chrome/browser/chromeos/dbus/session_manager_client.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/signed_settings_temp_storage.h"
 #include "chrome/browser/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "content/browser/browser_thread.h"
 
 namespace chromeos {
 using google::protobuf::RepeatedPtrField;
 using std::string;
@@ skipping 196 matching lines @@
                 SignedSettings::Delegate<bool>* d);
   virtual ~StorePolicyOp();
   void Execute();
   void Fail(SignedSettings::ReturnCode code);
   void Succeed(bool value);
   // Implementation of OwnerManager::Delegate
   void OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
                        const std::vector<uint8>& payload);
 
  private:
-  static void OnBoolComplete(void* delegate, bool success);
+  void OnBoolComplete(bool success);
   // Always call d_->OnSettingOpCompleted() via this call.
   // It guarantees that the callback will not be triggered until _after_
   // Execute() returns, which is implicitly assumed by SignedSettingsHelper
   // in some cases.
   void PerformCallback(SignedSettings::ReturnCode code, bool value);
 
   em::PolicyFetchResponse* policy_;
   SignedSettings::Delegate<bool>* d_;
 
   void RequestStorePolicy();
 };
 
 class RetrievePolicyOp : public SignedSettings {
  public:
   explicit RetrievePolicyOp(
       SignedSettings::Delegate<const em::PolicyFetchResponse&>* d);
   virtual ~RetrievePolicyOp();
   void Execute();
   void Fail(SignedSettings::ReturnCode code);
   void Succeed(const em::PolicyFetchResponse& value);
   // Implementation of OwnerManager::Delegate
   void OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
                        const std::vector<uint8>& payload);
 
  private:
-  static void OnStringComplete(void* delegate,
-                               const char* policy,
-                               const unsigned int len);
+  void OnStringComplete(const std::string& serialized_proto);
   // Always call d_->OnSettingOpCompleted() via this call.
   // It guarantees that the callback will not be triggered until _after_
   // Execute() returns, which is implicitly assumed by SignedSettingsHelper
   // in some cases.
   void PerformCallback(SignedSettings::ReturnCode code,
                        const em::PolicyFetchResponse& value);
 
-  void ProcessPolicy(const char* out, const unsigned int len);
+  void ProcessPolicy(const std::string& serialized_proto);
 
   em::PolicyFetchResponse policy_;
   SignedSettings::Delegate<const em::PolicyFetchResponse&>* d_;
 };
 
 // static
 SignedSettings* SignedSettings::CreateCheckWhitelistOp(
     const std::string& email,
     SignedSettings::Delegate<bool>* d) {
   DCHECK(d != NULL);
@@ skipping 496 matching lines @@
 }
 
 StorePolicyOp::StorePolicyOp(em::PolicyFetchResponse* policy,
                              SignedSettings::Delegate<bool>* d)
     : policy_(policy),
       d_(d) {
 }
 
 StorePolicyOp::~StorePolicyOp() {}
 
-// static
-void StorePolicyOp::OnBoolComplete(void* delegate, bool success) {
-  StorePolicyOp* op = static_cast<StorePolicyOp*>(delegate);
+void StorePolicyOp::OnBoolComplete(bool success) {
   if (success)
-    op->Succeed(true);
+    Succeed(true);
   else
-    op->Fail(NOT_FOUND);
+    Fail(NOT_FOUND);
 }
 
 void StorePolicyOp::Execute() {
   // get protobuf contents to sign
   if (!policy_->has_policy_data())
     Fail(OPERATION_FAILED);
   else if (!policy_->has_policy_data_signature())
     service_->StartSigningAttempt(policy_->policy_data(), this);
   else
     RequestStorePolicy();
@@ skipping 36 matching lines @@
     policy_->set_policy_data_signature(std::string(payload.begin(),
                                                    payload.end()));
     RequestStorePolicy();
     return;
   }
   Fail(SignedSettings::MapKeyOpCode(return_code));
 }
 
 void StorePolicyOp::RequestStorePolicy() {
   std::string serialized;
-  if (policy_->SerializeToString(&serialized) &&
-      CrosLibrary::Get()->EnsureLoaded()) {
-    CrosLibrary::Get()->GetLoginLibrary()->RequestStorePolicy(
+  if (policy_->SerializeToString(&serialized)) {
+    DBusThreadManager::Get()->session_manager_client()->StorePolicy(
         serialized,
-        &StorePolicyOp::OnBoolComplete,
-        this);
+        base::Bind(&StorePolicyOp::OnBoolComplete, this));
   } else {
     Fail(OPERATION_FAILED);
   }
 }
 
 void StorePolicyOp::PerformCallback(SignedSettings::ReturnCode code,
                                     bool value) {
   d_->OnSettingsOpCompleted(code, value);
 }
 
 RetrievePolicyOp::RetrievePolicyOp(
     SignedSettings::Delegate<const em::PolicyFetchResponse&>* d)
     : d_(d) {
 }
 
 RetrievePolicyOp::~RetrievePolicyOp() {}
 
 void RetrievePolicyOp::Execute() {
-  if (CrosLibrary::Get()->EnsureLoaded()) {
-    CrosLibrary::Get()->GetLoginLibrary()->RequestRetrievePolicy(
-        &RetrievePolicyOp::OnStringComplete, this);
-  } else {
-    Fail(OPERATION_FAILED);
-  }
+  DBusThreadManager::Get()->session_manager_client()->RetrievePolicy(
+      base::Bind(&RetrievePolicyOp::OnStringComplete, this));
 }
 
 void RetrievePolicyOp::Fail(SignedSettings::ReturnCode code) {
   VLOG(2) << "RetrievePolicyOp::Execute() failed with " << code;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&RetrievePolicyOp::PerformCallback, this, code,
                  em::PolicyFetchResponse()));
 }
 
@@ skipping 19 matching lines @@
                    payload));
     return;
   }
   // Now, sure we're on the UI thread.
   if (return_code == OwnerManager::SUCCESS)
     Succeed(policy_);
   else
     Fail(SignedSettings::MapKeyOpCode(return_code));
 }
 
-// static
-void RetrievePolicyOp::OnStringComplete(void* delegate,
-                                        const char* out,
-                                        const unsigned int len) {
-  RetrievePolicyOp* op = static_cast<RetrievePolicyOp*>(delegate);
-  op->ProcessPolicy(out, len);
+void RetrievePolicyOp::OnStringComplete(const std::string& serialized_proto) {
+  ProcessPolicy(serialized_proto);
 }
 
-void RetrievePolicyOp::ProcessPolicy(const char* out, const unsigned int len) {
-  if (!out || !policy_.ParseFromString(std::string(out, len)) ||
+void RetrievePolicyOp::ProcessPolicy(const std::string& serialized_proto) {
+  if (!policy_.ParseFromString(serialized_proto) ||
       (!policy_.has_policy_data() && !policy_.has_policy_data_signature())) {
     Fail(NOT_FOUND);
     return;
   }
   if (!policy_.has_policy_data()) {
     Fail(OPERATION_FAILED);
     return;
   }
   if (!policy_.has_policy_data_signature()) {
     Fail(BAD_SIGNATURE);
     return;
   }
   std::vector<uint8> sig;
   const char* sig_ptr = policy_.policy_data_signature().c_str();
   sig.assign(sig_ptr, sig_ptr + policy_.policy_data_signature().length());
   service_->StartVerifyAttempt(policy_.policy_data(), sig, this);
 }
 
 void RetrievePolicyOp::PerformCallback(SignedSettings::ReturnCode code,
                                        const em::PolicyFetchResponse& value) {
   d_->OnSettingsOpCompleted(code, value);
 }
 
 }  // namespace chromeos