Chrome-side lockbox bindings

chrome/browser/chromeos/cros/cryptohome_library.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/cros/cryptohome_library.h"
 
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 143 matching lines @@
   }
 
   void TpmCanAttemptOwnership() {
     chromeos::CryptohomeTpmCanAttemptOwnership();
   }
 
   void TpmClearStoredPassword() {
     chromeos::CryptohomeTpmClearStoredPassword();
   }
 
+  bool InstallAttributesGet(const std::string& name, std::string* value) {
+    char* local_value;
+    bool done =
+        chromeos::CryptohomeInstallAttributesGet(name.c_str(), &local_value);
+    *value = local_value;
+    chromeos::CryptohomeFreeString(local_value);
+    return done;
+  }
+
+  bool InstallAttributesSet(const std::string& name, const std::string& value) {
+    return chromeos::CryptohomeInstallAttributesSet(name.c_str(),
+                                                    value.c_str());
+  }
+
+  int InstallAttributesCount() {
+    return chromeos::CryptohomeInstallAttributesCount();
+  }
+
+  bool InstallAttributesFinalize() {
+    return chromeos::CryptohomeInstallAttributesFinalize();
+  }
+
+  bool InstallAttributesIsReady() {
+    return chromeos::CryptohomeInstallAttributesIsReady();
+  }
+
+  bool InstallAttributesIsSecure() {
+    return chromeos::CryptohomeInstallAttributesIsSecure();
+  }
+
+  bool InstallAttributesIsInvalid() {
+    return chromeos::CryptohomeInstallAttributesIsInvalid();
+  }
+
+  bool InstallAttributesIsFirstInstall() {
+    return chromeos::CryptohomeInstallAttributesIsFirstInstall();
+  }
+
  private:
   static void Handler(const chromeos::CryptohomeAsyncCallStatus& event,
                       void* cryptohome_library) {
     CryptohomeLibraryImpl* library =
         reinterpret_cast<CryptohomeLibraryImpl*>(cryptohome_library);
     library->Dispatch(event);
   }
 
   void Init() {
     cryptohome_connection_ = chromeos::CryptohomeMonitorSession(&Handler, this);
@@ skipping 150 matching lines @@
 
   bool TpmGetPassword(std::string* password) {
     *password = "Stub-TPM-password";
     return true;
   }
 
   void TpmCanAttemptOwnership() {}
 
   void TpmClearStoredPassword() {}
 
+  bool InstallAttributesGet(const std::string& name, std::string* value) {
+    if (lockbox_.find(name) != lockbox_.end()) {
+      *value = lockbox_[name];
+      return true;
+    }
+    return false;
+  }
+
+  bool InstallAttributesSet(const std::string& name, const std::string& value) {
+    lockbox_[name] = value;

[kmixter1, 2011/04/14 16:52:22]

why?  Is this just until the actual implementation lands?

+    return true;
+  }
+
+  int InstallAttributesCount() {
+    return lockbox_.size();
+  }
+
+  bool InstallAttributesFinalize() {
+    locked_ = true;
+    return true;
+  }
+
+  bool InstallAttributesIsReady() {
+    return true;
+  }
+
+  bool InstallAttributesIsSecure() {
+    return locked_;
+  }
+
+  bool InstallAttributesIsInvalid() {
+    return false;
+  }
+
+  bool InstallAttributesIsFirstInstall() {
+    return false;
+  }
+
  private:
   static void DoStubCallback(Delegate* callback) {
     if (callback)
       callback->OnComplete(true, kCryptohomeMountErrorNone);
   }
+
+  std::map<std::string, std::string> lockbox_;
+  bool locked_;
   DISALLOW_COPY_AND_ASSIGN(CryptohomeLibraryStubImpl);
 };
 
 // static
 CryptohomeLibrary* CryptohomeLibrary::GetImpl(bool stub) {
   if (stub)
     return new CryptohomeLibraryStubImpl();
   else
     return new CryptohomeLibraryImpl();
 }
 
 } // namespace chromeos