[Chrome OS] Plumb new error codes from SignedSettings to consumers of the API

chrome/browser/chromeos/login/signed_settings.cc

 // Copyright (c) 2010 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/ref_counted.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/login_library.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/signed_settings_temp_storage.h"
 
 namespace chromeos {
 
 SignedSettings::SignedSettings()
     : service_(OwnershipService::GetSharedInstance()) {
 }
 
 SignedSettings::~SignedSettings() {}
 
-SignedSettings::FailureCode SignedSettings::MapKeyOpCode(
+SignedSettings::ReturnCode SignedSettings::MapKeyOpCode(
     OwnerManager::KeyOpCode return_code) {
   return (return_code == OwnerManager::KEY_UNAVAILABLE ?
           KEY_UNAVAILABLE : OPERATION_FAILED);
 }
 
 class CheckWhitelistOp : public SignedSettings {
  public:
   CheckWhitelistOp(const std::string& email,
                    SignedSettings::Delegate<bool>* d);
   virtual ~CheckWhitelistOp();
@@ skipping 104 matching lines @@
     : email_(email),
       d_(d) {
 }
 
 CheckWhitelistOp::~CheckWhitelistOp() {}
 
 void CheckWhitelistOp::Execute() {
   CHECK(chromeos::CrosLibrary::Get()->EnsureLoaded());
   std::vector<uint8> sig;
   if (!CrosLibrary::Get()->GetLoginLibrary()->CheckWhitelist(email_, &sig)) {
-    d_->OnSettingsOpFailed(NOT_FOUND);
+    d_->OnSettingsOpCompleted(NOT_FOUND, false);
     return;
   }
   // Posts a task to the FILE thread to verify |sig|.
   service_->StartVerifyAttempt(email_, sig, this);
 }
 
 void CheckWhitelistOp::OnKeyOpComplete(
     const OwnerManager::KeyOpCode return_code,
     const std::vector<uint8>& payload) {
   // Ensure we're on the UI thread, due to the need to send DBus traffic.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &CheckWhitelistOp::OnKeyOpComplete,
                           return_code, payload));
     return;
   }
   if (return_code == OwnerManager::SUCCESS) {
-    d_->OnSettingsOpSucceeded(true);
+    d_->OnSettingsOpCompleted(SUCCESS, true);
   } else {
-    d_->OnSettingsOpFailed(SignedSettings::MapKeyOpCode(return_code));
+    d_->OnSettingsOpCompleted(SignedSettings::MapKeyOpCode(return_code), false);
   }
 }
 
 WhitelistOp::WhitelistOp(const std::string& email,
                          bool add_to_whitelist,
                          SignedSettings::Delegate<bool>* d)
     : email_(email),
       add_to_whitelist_(add_to_whitelist),
       d_(d) {
 }
@@ skipping 13 matching lines @@
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &WhitelistOp::OnKeyOpComplete,
                           return_code, payload));
     return;
   }
   // Now, sure we're on the UI thread.
   if (return_code == OwnerManager::SUCCESS) {
     // OnComplete() will be called by this call, if it succeeds.
     if (!InitiateWhitelistOp(payload))
-      d_->OnSettingsOpFailed(OPERATION_FAILED);
+      d_->OnSettingsOpCompleted(OPERATION_FAILED, false);
   } else {
-    d_->OnSettingsOpFailed(SignedSettings::MapKeyOpCode(return_code));
+    d_->OnSettingsOpCompleted(SignedSettings::MapKeyOpCode(return_code), false);
   }
 }
 
 void WhitelistOp::OnComplete(bool value) {
   if (value)
-    d_->OnSettingsOpSucceeded(value);
+    d_->OnSettingsOpCompleted(SUCCESS, value);
   else
-    d_->OnSettingsOpFailed(NOT_FOUND);
+    d_->OnSettingsOpCompleted(NOT_FOUND, false);
 }
 
 bool WhitelistOp::InitiateWhitelistOp(const std::vector<uint8>& signature) {
   LoginLibrary* library = CrosLibrary::Get()->GetLoginLibrary();
   if (add_to_whitelist_)
     return library->WhitelistAsync(email_, signature, this);
   return library->UnwhitelistAsync(email_, signature, this);
 }
 
 StorePropertyOp::StorePropertyOp(const std::string& name,
                                  const std::string& value,
                                  SignedSettings::Delegate<bool>* d)
     : name_(name),
       value_(value),
       d_(d) {
 }
 
 StorePropertyOp::~StorePropertyOp() {}
 
 void StorePropertyOp::Execute() {
   if (!service_->IsAlreadyOwned()) {
     if (g_browser_process &&
         g_browser_process->local_state() &&
         SignedSettingsTempStorage::Store(name_, value_,
                                          g_browser_process->local_state())) {
-      d_->OnSettingsOpSucceeded(true);
+      d_->OnSettingsOpCompleted(SUCCESS, true);
       return;
     }
   }
   // Posts a task to the FILE thread to sign |name_|=|value_|.
   std::string to_sign = base::StringPrintf("%s=%s",
                                            name_.c_str(),
                                            value_.c_str());
   service_->StartSigningAttempt(to_sign, this);
 }
 
 void StorePropertyOp::OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
                                       const std::vector<uint8>& payload) {
   // Ensure we're on the UI thread, due to the need to send DBus traffic.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &StorePropertyOp::OnKeyOpComplete,
                           return_code, payload));
     return;
   }
+  VLOG(2) << "StorePropertyOp::OnKeyOpComplete return_code = " << return_code;
   // Now, sure we're on the UI thread.
   if (return_code == OwnerManager::SUCCESS) {
     // OnComplete() will be called by this call, if it succeeds.
     if (!CrosLibrary::Get()->GetLoginLibrary()->StorePropertyAsync(name_,
                                                                    value_,
                                                                    payload,
                                                                    this)) {
-      d_->OnSettingsOpFailed(OPERATION_FAILED);
+      d_->OnSettingsOpCompleted(OPERATION_FAILED, false);
     }
   } else {
-    d_->OnSettingsOpFailed(SignedSettings::MapKeyOpCode(return_code));
+    d_->OnSettingsOpCompleted(SignedSettings::MapKeyOpCode(return_code), false);
   }
 }
 
 void StorePropertyOp::OnComplete(bool value) {
   if (value)
-    d_->OnSettingsOpSucceeded(value);
+    d_->OnSettingsOpCompleted(SUCCESS, value);
   else
-    d_->OnSettingsOpFailed(NOT_FOUND);
+    d_->OnSettingsOpCompleted(NOT_FOUND, false);
 }
 
 RetrievePropertyOp::RetrievePropertyOp(const std::string& name,
                                        SignedSettings::Delegate<std::string>* d)
     : name_(name),
       d_(d) {
 }
 
 RetrievePropertyOp::~RetrievePropertyOp() {}
 
@@ skipping 14 matching lines @@
           NewRunnableMethod(this,
                             &RetrievePropertyOp::OnKeyOpComplete,
                             OwnerManager::SUCCESS, std::vector<uint8>()));
       return;
     }
   }
   std::vector<uint8> sig;
   if (!CrosLibrary::Get()->GetLoginLibrary()->RetrieveProperty(name_,
                                                                &value_,
                                                                &sig)) {
-    d_->OnSettingsOpFailed(NOT_FOUND);
+    d_->OnSettingsOpCompleted(NOT_FOUND, std::string());
     return;
   }
   std::string to_verify = base::StringPrintf("%s=%s",
                                              name_.c_str(),
                                              value_.c_str());
   // Posts a task to the FILE thread to verify |sig|.
   service_->StartVerifyAttempt(to_verify, sig, this);
 }
 
 void RetrievePropertyOp::OnKeyOpComplete(
     const OwnerManager::KeyOpCode return_code,
     const std::vector<uint8>& payload) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &RetrievePropertyOp::OnKeyOpComplete,
                           return_code, payload));
     return;
   }
   // Now, sure we're on the UI thread.
   if (return_code == OwnerManager::SUCCESS)
-    d_->OnSettingsOpSucceeded(value_);
+    d_->OnSettingsOpCompleted(SUCCESS, value_);
   else
-    d_->OnSettingsOpFailed(SignedSettings::MapKeyOpCode(return_code));
+    d_->OnSettingsOpCompleted(SignedSettings::MapKeyOpCode(return_code),
+                              std::string());
 }
 
 }  // namespace chromeos