trunks: Replace CHROMEOS_EXPORT with TRUNKS_EXPORT.
BUG=None
TEST=unit
Change-Id: Ia871889da16e77e7c77b814d7ff311580add560c
Reviewed-on: https://chromium-review.googlesource.com/260011
Reviewed-by: Utkarsh Sanghi <usanghi@chromium.org>
Reviewed-by: Alex Vakulenko <avakulenko@chromium.org>
Commit-Queue: Darren Krahn <dkrahn@chromium.org>
Tested-by: Darren Krahn <dkrahn@chromium.org>
diff --git a/authorization_session_impl.h b/authorization_session_impl.h
index d53136c..ee5bdcd 100644
--- a/authorization_session_impl.h
+++ b/authorization_session_impl.h
@@ -10,10 +10,10 @@
#include <string>
#include <base/macros.h>
-#include <chromeos/chromeos_export.h>
#include "trunks/hmac_authorization_delegate.h"
#include "trunks/password_authorization_delegate.h"
+#include "trunks/trunks_export.h"
#include "trunks/trunks_factory.h"
namespace trunks {
@@ -34,7 +34,7 @@
* TPM Ownership is taken. This is because starting a session uses the
* SaltingKey, which is only created after ownership is taken.
*/
-class CHROMEOS_EXPORT AuthorizationSessionImpl: public AuthorizationSession {
+class TRUNKS_EXPORT AuthorizationSessionImpl: public AuthorizationSession {
public:
// The constructor for AuthroizationSessionImpl needs a factory. In
// producation code, this factory is used to access the TPM class to forward
diff --git a/error_codes.cc b/error_codes.cc
index 4129e01..aab3b0b 100644
--- a/error_codes.cc
+++ b/error_codes.cc
@@ -202,7 +202,7 @@
return ss.str();
}
-TPM_RC CHROMEOS_EXPORT GetFormatOneError(TPM_RC error) {
+TPM_RC GetFormatOneError(TPM_RC error) {
if (IsFormatOne(error)) {
return (error & kFormatOneErrorMask);
}
diff --git a/error_codes.h b/error_codes.h
index 90dd787..c7399cd 100644
--- a/error_codes.h
+++ b/error_codes.h
@@ -7,9 +7,8 @@
#include <string>
-#include <chromeos/chromeos_export.h>
-
#include "trunks/tpm_generated.h" // For TPM_RC.
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -57,13 +56,13 @@
const TPM_RC SAPI_RC_BAD_TCTI_STRUCTURE = kSapiErrorBase + 15;
// Returns a description of |error|.
-std::string CHROMEOS_EXPORT GetErrorString(TPM_RC error);
+TRUNKS_EXPORT std::string GetErrorString(TPM_RC error);
// Strips the P and N bits from a 'format one' error. If the given error code
// is not a format one error, it is returned as is. The error that is returned
// can be compared to TPM_RC_* constant values. See TPM 2.0 Part 2 Section 6.6
// for details on format one errors.
-TPM_RC CHROMEOS_EXPORT GetFormatOneError(TPM_RC error);
+TRUNKS_EXPORT TPM_RC GetFormatOneError(TPM_RC error);
} // namespace trunks
diff --git a/generator/generator.py b/generator/generator.py
index 1c727f7..ae16150 100755
--- a/generator/generator.py
+++ b/generator/generator.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python2
# Copyright 2014 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
@@ -87,7 +87,8 @@
#include <base/basictypes.h>
#include <base/callback_forward.h>
-#include <chromeos/chromeos_export.h>
+
+#include "trunks/trunks_export.h"
"""
_IMPLEMENTATION_FILE_INCLUDES = """
#include <string>
@@ -120,7 +121,7 @@
class CommandTransceiver;
"""
_CLASS_BEGIN = """
-class CHROMEOS_EXPORT Tpm {
+class TRUNKS_EXPORT Tpm {
public:
// Does not take ownership of |transceiver|.
explicit Tpm(CommandTransceiver* transceiver) : transceiver_(transceiver) {}
@@ -186,24 +187,24 @@
}
"""
_SERIALIZE_DECLARATION = """
-TPM_RC CHROMEOS_EXPORT Serialize_%(type)s(
+TRUNKS_EXPORT TPM_RC Serialize_%(type)s(
const %(type)s& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_%(type)s(
+TRUNKS_EXPORT TPM_RC Parse_%(type)s(
std::string* buffer,
%(type)s* value,
std::string* value_bytes);
"""
_SIMPLE_TPM2B_HELPERS_DECLARATION = """
-%(type)s CHROMEOS_EXPORT Make_%(type)s(
+TRUNKS_EXPORT %(type)s Make_%(type)s(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_%(type)s(
+TRUNKS_EXPORT std::string StringFrom_%(type)s(
const %(type)s& tpm2b);
"""
_COMPLEX_TPM2B_HELPERS_DECLARATION = """
-%(type)s CHROMEOS_EXPORT Make_%(type)s(
+TRUNKS_EXPORT %(type)s Make_%(type)s(
const %(inner_type)s& inner);
"""
diff --git a/hmac_authorization_delegate.h b/hmac_authorization_delegate.h
index 86a4816..c06f022 100644
--- a/hmac_authorization_delegate.h
+++ b/hmac_authorization_delegate.h
@@ -8,12 +8,12 @@
#include <string>
#include <base/gtest_prod_util.h>
-#include <chromeos/chromeos_export.h>
#include <crypto/secure_hash.h>
#include <gtest/gtest_prod.h>
#include "trunks/authorization_delegate.h"
#include "trunks/tpm_generated.h"
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -47,7 +47,7 @@
* hmac.set_entity_auth_value(...);
* tpm.Load(..., &hmac);
*/
-class CHROMEOS_EXPORT HmacAuthorizationDelegate: public AuthorizationDelegate {
+class TRUNKS_EXPORT HmacAuthorizationDelegate: public AuthorizationDelegate {
public:
HmacAuthorizationDelegate();
~HmacAuthorizationDelegate() override;
diff --git a/password_authorization_delegate.h b/password_authorization_delegate.h
index 49eb8a1..cc3d819 100644
--- a/password_authorization_delegate.h
+++ b/password_authorization_delegate.h
@@ -8,10 +8,10 @@
#include <string>
#include <base/gtest_prod_util.h>
-#include <chromeos/chromeos_export.h>
#include "trunks/authorization_delegate.h"
#include "trunks/tpm_generated.h"
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -20,7 +20,7 @@
// initialization of this delegate, we feed in the plaintext password. This
// password is then used to authorize the commands issued with this delegate.
// This delegate performs no parameter encryption.
-class CHROMEOS_EXPORT PasswordAuthorizationDelegate
+class TRUNKS_EXPORT PasswordAuthorizationDelegate
: public AuthorizationDelegate {
public:
explicit PasswordAuthorizationDelegate(const std::string& password);
diff --git a/scoped_key_handle.h b/scoped_key_handle.h
index a865b9a..0ca72ff 100644
--- a/scoped_key_handle.h
+++ b/scoped_key_handle.h
@@ -5,9 +5,8 @@
#ifndef TRUNKS_SCOPED_KEY_HANDLE_H_
#define TRUNKS_SCOPED_KEY_HANDLE_H_
-#include <chromeos/chromeos_export.h>
-
#include "trunks/tpm_generated.h"
+#include "trunks/trunks_export.h"
#include "trunks/trunks_factory.h"
namespace trunks {
@@ -17,7 +16,7 @@
* It provides a destructor that cleans up TPM resources associated with
* that handle.
*/
-class CHROMEOS_EXPORT ScopedKeyHandle {
+class TRUNKS_EXPORT ScopedKeyHandle {
public:
// We provide a factory to the constructor so that we can later free
// resources associated with the handle.
diff --git a/tpm_generated.h b/tpm_generated.h
index 0c1e667..7a984c3 100644
--- a/tpm_generated.h
+++ b/tpm_generated.h
@@ -11,7 +11,8 @@
#include <base/basictypes.h>
#include <base/callback_forward.h>
-#include <chromeos/chromeos_export.h>
+
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -1608,2110 +1609,2110 @@
};
-TPM_RC CHROMEOS_EXPORT Serialize_uint8_t(
+TRUNKS_EXPORT TPM_RC Serialize_uint8_t(
const uint8_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_uint8_t(
+TRUNKS_EXPORT TPM_RC Parse_uint8_t(
std::string* buffer,
uint8_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_int8_t(
+TRUNKS_EXPORT TPM_RC Serialize_int8_t(
const int8_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_int8_t(
+TRUNKS_EXPORT TPM_RC Parse_int8_t(
std::string* buffer,
int8_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_int(
+TRUNKS_EXPORT TPM_RC Serialize_int(
const int& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_int(
+TRUNKS_EXPORT TPM_RC Parse_int(
std::string* buffer,
int* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_uint16_t(
+TRUNKS_EXPORT TPM_RC Serialize_uint16_t(
const uint16_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_uint16_t(
+TRUNKS_EXPORT TPM_RC Parse_uint16_t(
std::string* buffer,
uint16_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_int16_t(
+TRUNKS_EXPORT TPM_RC Serialize_int16_t(
const int16_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_int16_t(
+TRUNKS_EXPORT TPM_RC Parse_int16_t(
std::string* buffer,
int16_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_uint32_t(
+TRUNKS_EXPORT TPM_RC Serialize_uint32_t(
const uint32_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_uint32_t(
+TRUNKS_EXPORT TPM_RC Parse_uint32_t(
std::string* buffer,
uint32_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_int32_t(
+TRUNKS_EXPORT TPM_RC Serialize_int32_t(
const int32_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_int32_t(
+TRUNKS_EXPORT TPM_RC Parse_int32_t(
std::string* buffer,
int32_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_uint64_t(
+TRUNKS_EXPORT TPM_RC Serialize_uint64_t(
const uint64_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_uint64_t(
+TRUNKS_EXPORT TPM_RC Parse_uint64_t(
std::string* buffer,
uint64_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_int64_t(
+TRUNKS_EXPORT TPM_RC Serialize_int64_t(
const int64_t& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_int64_t(
+TRUNKS_EXPORT TPM_RC Parse_int64_t(
std::string* buffer,
int64_t* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_UINT8(
+TRUNKS_EXPORT TPM_RC Serialize_UINT8(
const UINT8& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_UINT8(
+TRUNKS_EXPORT TPM_RC Parse_UINT8(
std::string* buffer,
UINT8* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_BYTE(
+TRUNKS_EXPORT TPM_RC Serialize_BYTE(
const BYTE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_BYTE(
+TRUNKS_EXPORT TPM_RC Parse_BYTE(
std::string* buffer,
BYTE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_INT8(
+TRUNKS_EXPORT TPM_RC Serialize_INT8(
const INT8& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_INT8(
+TRUNKS_EXPORT TPM_RC Parse_INT8(
std::string* buffer,
INT8* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_BOOL(
+TRUNKS_EXPORT TPM_RC Serialize_BOOL(
const BOOL& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_BOOL(
+TRUNKS_EXPORT TPM_RC Parse_BOOL(
std::string* buffer,
BOOL* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_UINT16(
+TRUNKS_EXPORT TPM_RC Serialize_UINT16(
const UINT16& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_UINT16(
+TRUNKS_EXPORT TPM_RC Parse_UINT16(
std::string* buffer,
UINT16* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_INT16(
+TRUNKS_EXPORT TPM_RC Serialize_INT16(
const INT16& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_INT16(
+TRUNKS_EXPORT TPM_RC Parse_INT16(
std::string* buffer,
INT16* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_UINT32(
+TRUNKS_EXPORT TPM_RC Serialize_UINT32(
const UINT32& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_UINT32(
+TRUNKS_EXPORT TPM_RC Parse_UINT32(
std::string* buffer,
UINT32* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_INT32(
+TRUNKS_EXPORT TPM_RC Serialize_INT32(
const INT32& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_INT32(
+TRUNKS_EXPORT TPM_RC Parse_INT32(
std::string* buffer,
INT32* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_UINT64(
+TRUNKS_EXPORT TPM_RC Serialize_UINT64(
const UINT64& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_UINT64(
+TRUNKS_EXPORT TPM_RC Parse_UINT64(
std::string* buffer,
UINT64* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_INT64(
+TRUNKS_EXPORT TPM_RC Serialize_INT64(
const INT64& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_INT64(
+TRUNKS_EXPORT TPM_RC Parse_INT64(
std::string* buffer,
INT64* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_ALGORITHM_ID(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_ALGORITHM_ID(
const TPM_ALGORITHM_ID& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_ALGORITHM_ID(
+TRUNKS_EXPORT TPM_RC Parse_TPM_ALGORITHM_ID(
std::string* buffer,
TPM_ALGORITHM_ID* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_MODIFIER_INDICATOR(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_MODIFIER_INDICATOR(
const TPM_MODIFIER_INDICATOR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_MODIFIER_INDICATOR(
+TRUNKS_EXPORT TPM_RC Parse_TPM_MODIFIER_INDICATOR(
std::string* buffer,
TPM_MODIFIER_INDICATOR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_AUTHORIZATION_SIZE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_AUTHORIZATION_SIZE(
const TPM_AUTHORIZATION_SIZE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_AUTHORIZATION_SIZE(
+TRUNKS_EXPORT TPM_RC Parse_TPM_AUTHORIZATION_SIZE(
std::string* buffer,
TPM_AUTHORIZATION_SIZE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_PARAMETER_SIZE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_PARAMETER_SIZE(
const TPM_PARAMETER_SIZE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_PARAMETER_SIZE(
+TRUNKS_EXPORT TPM_RC Parse_TPM_PARAMETER_SIZE(
std::string* buffer,
TPM_PARAMETER_SIZE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_KEY_SIZE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_KEY_SIZE(
const TPM_KEY_SIZE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_KEY_SIZE(
+TRUNKS_EXPORT TPM_RC Parse_TPM_KEY_SIZE(
std::string* buffer,
TPM_KEY_SIZE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_KEY_BITS(
const TPM_KEY_BITS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Parse_TPM_KEY_BITS(
std::string* buffer,
TPM_KEY_BITS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_HANDLE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_HANDLE(
const TPM_HANDLE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_HANDLE(
+TRUNKS_EXPORT TPM_RC Parse_TPM_HANDLE(
std::string* buffer,
TPM_HANDLE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_NONCE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_NONCE(
const TPM2B_NONCE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_NONCE(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_NONCE(
std::string* buffer,
TPM2B_NONCE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_AUTH(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_AUTH(
const TPM2B_AUTH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_AUTH(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_AUTH(
std::string* buffer,
TPM2B_AUTH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_OPERAND(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_OPERAND(
const TPM2B_OPERAND& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_OPERAND(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_OPERAND(
std::string* buffer,
TPM2B_OPERAND* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_HMAC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_HMAC(
const TPMS_SCHEME_HMAC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_HMAC(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_HMAC(
std::string* buffer,
TPMS_SCHEME_HMAC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_RSASSA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_RSASSA(
const TPMS_SCHEME_RSASSA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_RSASSA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_RSASSA(
std::string* buffer,
TPMS_SCHEME_RSASSA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_RSAPSS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_RSAPSS(
const TPMS_SCHEME_RSAPSS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_RSAPSS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_RSAPSS(
std::string* buffer,
TPMS_SCHEME_RSAPSS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_ECDSA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_ECDSA(
const TPMS_SCHEME_ECDSA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_ECDSA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_ECDSA(
std::string* buffer,
TPMS_SCHEME_ECDSA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_SM2(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_SM2(
const TPMS_SCHEME_SM2& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_SM2(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_SM2(
std::string* buffer,
TPMS_SCHEME_SM2* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_ECSCHNORR(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_ECSCHNORR(
const TPMS_SCHEME_ECSCHNORR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_ECSCHNORR(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_ECSCHNORR(
std::string* buffer,
TPMS_SCHEME_ECSCHNORR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_YES_NO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_YES_NO(
const TPMI_YES_NO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_YES_NO(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_YES_NO(
std::string* buffer,
TPMI_YES_NO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_DH_OBJECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_DH_OBJECT(
const TPMI_DH_OBJECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_DH_OBJECT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_DH_OBJECT(
std::string* buffer,
TPMI_DH_OBJECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_DH_PERSISTENT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_DH_PERSISTENT(
const TPMI_DH_PERSISTENT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_DH_PERSISTENT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_DH_PERSISTENT(
std::string* buffer,
TPMI_DH_PERSISTENT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_DH_ENTITY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_DH_ENTITY(
const TPMI_DH_ENTITY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_DH_ENTITY(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_DH_ENTITY(
std::string* buffer,
TPMI_DH_ENTITY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_DH_PCR(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_DH_PCR(
const TPMI_DH_PCR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_DH_PCR(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_DH_PCR(
std::string* buffer,
TPMI_DH_PCR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_SH_AUTH_SESSION(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_SH_AUTH_SESSION(
const TPMI_SH_AUTH_SESSION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_SH_AUTH_SESSION(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_SH_AUTH_SESSION(
std::string* buffer,
TPMI_SH_AUTH_SESSION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_SH_HMAC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_SH_HMAC(
const TPMI_SH_HMAC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_SH_HMAC(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_SH_HMAC(
std::string* buffer,
TPMI_SH_HMAC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_SH_POLICY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_SH_POLICY(
const TPMI_SH_POLICY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_SH_POLICY(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_SH_POLICY(
std::string* buffer,
TPMI_SH_POLICY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_DH_CONTEXT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_DH_CONTEXT(
const TPMI_DH_CONTEXT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_DH_CONTEXT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_DH_CONTEXT(
std::string* buffer,
TPMI_DH_CONTEXT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_HIERARCHY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_HIERARCHY(
const TPMI_RH_HIERARCHY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_HIERARCHY(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_HIERARCHY(
std::string* buffer,
TPMI_RH_HIERARCHY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_ENABLES(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_ENABLES(
const TPMI_RH_ENABLES& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_ENABLES(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_ENABLES(
std::string* buffer,
TPMI_RH_ENABLES* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_HIERARCHY_AUTH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_HIERARCHY_AUTH(
const TPMI_RH_HIERARCHY_AUTH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_HIERARCHY_AUTH(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_HIERARCHY_AUTH(
std::string* buffer,
TPMI_RH_HIERARCHY_AUTH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_PLATFORM(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_PLATFORM(
const TPMI_RH_PLATFORM& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_PLATFORM(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_PLATFORM(
std::string* buffer,
TPMI_RH_PLATFORM* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_OWNER(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_OWNER(
const TPMI_RH_OWNER& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_OWNER(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_OWNER(
std::string* buffer,
TPMI_RH_OWNER* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_ENDORSEMENT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_ENDORSEMENT(
const TPMI_RH_ENDORSEMENT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_ENDORSEMENT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_ENDORSEMENT(
std::string* buffer,
TPMI_RH_ENDORSEMENT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_PROVISION(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_PROVISION(
const TPMI_RH_PROVISION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_PROVISION(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_PROVISION(
std::string* buffer,
TPMI_RH_PROVISION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_CLEAR(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_CLEAR(
const TPMI_RH_CLEAR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_CLEAR(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_CLEAR(
std::string* buffer,
TPMI_RH_CLEAR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_NV_AUTH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_NV_AUTH(
const TPMI_RH_NV_AUTH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_NV_AUTH(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_NV_AUTH(
std::string* buffer,
TPMI_RH_NV_AUTH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_LOCKOUT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_LOCKOUT(
const TPMI_RH_LOCKOUT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_LOCKOUT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_LOCKOUT(
std::string* buffer,
TPMI_RH_LOCKOUT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RH_NV_INDEX(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RH_NV_INDEX(
const TPMI_RH_NV_INDEX& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RH_NV_INDEX(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RH_NV_INDEX(
std::string* buffer,
TPMI_RH_NV_INDEX* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_HASH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_HASH(
const TPMI_ALG_HASH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_HASH(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_HASH(
std::string* buffer,
TPMI_ALG_HASH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_ASYM(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_ASYM(
const TPMI_ALG_ASYM& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_ASYM(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_ASYM(
std::string* buffer,
TPMI_ALG_ASYM* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_SYM(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_SYM(
const TPMI_ALG_SYM& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_SYM(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_SYM(
std::string* buffer,
TPMI_ALG_SYM* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_SYM_OBJECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_SYM_OBJECT(
const TPMI_ALG_SYM_OBJECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_SYM_OBJECT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_SYM_OBJECT(
std::string* buffer,
TPMI_ALG_SYM_OBJECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_SYM_MODE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_SYM_MODE(
const TPMI_ALG_SYM_MODE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_SYM_MODE(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_SYM_MODE(
std::string* buffer,
TPMI_ALG_SYM_MODE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_KDF(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_KDF(
const TPMI_ALG_KDF& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_KDF(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_KDF(
std::string* buffer,
TPMI_ALG_KDF* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_SIG_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_SIG_SCHEME(
const TPMI_ALG_SIG_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_SIG_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_SIG_SCHEME(
std::string* buffer,
TPMI_ALG_SIG_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ECC_KEY_EXCHANGE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ECC_KEY_EXCHANGE(
const TPMI_ECC_KEY_EXCHANGE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ECC_KEY_EXCHANGE(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ECC_KEY_EXCHANGE(
std::string* buffer,
TPMI_ECC_KEY_EXCHANGE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ST_COMMAND_TAG(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ST_COMMAND_TAG(
const TPMI_ST_COMMAND_TAG& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ST_COMMAND_TAG(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ST_COMMAND_TAG(
std::string* buffer,
TPMI_ST_COMMAND_TAG* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ST_ATTEST(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ST_ATTEST(
const TPMI_ST_ATTEST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ST_ATTEST(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ST_ATTEST(
std::string* buffer,
TPMI_ST_ATTEST* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_AES_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_AES_KEY_BITS(
const TPMI_AES_KEY_BITS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_AES_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_AES_KEY_BITS(
std::string* buffer,
TPMI_AES_KEY_BITS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_SM4_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_SM4_KEY_BITS(
const TPMI_SM4_KEY_BITS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_SM4_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_SM4_KEY_BITS(
std::string* buffer,
TPMI_SM4_KEY_BITS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_KEYEDHASH_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_KEYEDHASH_SCHEME(
const TPMI_ALG_KEYEDHASH_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_KEYEDHASH_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_KEYEDHASH_SCHEME(
std::string* buffer,
TPMI_ALG_KEYEDHASH_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_ASYM_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_ASYM_SCHEME(
const TPMI_ALG_ASYM_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_ASYM_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_ASYM_SCHEME(
std::string* buffer,
TPMI_ALG_ASYM_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_RSA_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_RSA_SCHEME(
const TPMI_ALG_RSA_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_RSA_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_RSA_SCHEME(
std::string* buffer,
TPMI_ALG_RSA_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_RSA_DECRYPT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_RSA_DECRYPT(
const TPMI_ALG_RSA_DECRYPT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_RSA_DECRYPT(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_RSA_DECRYPT(
std::string* buffer,
TPMI_ALG_RSA_DECRYPT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_RSA_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_RSA_KEY_BITS(
const TPMI_RSA_KEY_BITS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_RSA_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_RSA_KEY_BITS(
std::string* buffer,
TPMI_RSA_KEY_BITS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_ECC_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_ECC_SCHEME(
const TPMI_ALG_ECC_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_ECC_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_ECC_SCHEME(
std::string* buffer,
TPMI_ALG_ECC_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ECC_CURVE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ECC_CURVE(
const TPMI_ECC_CURVE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ECC_CURVE(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ECC_CURVE(
std::string* buffer,
TPMI_ECC_CURVE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMI_ALG_PUBLIC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMI_ALG_PUBLIC(
const TPMI_ALG_PUBLIC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMI_ALG_PUBLIC(
+TRUNKS_EXPORT TPM_RC Parse_TPMI_ALG_PUBLIC(
std::string* buffer,
TPMI_ALG_PUBLIC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_ALGORITHM(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_ALGORITHM(
const TPMA_ALGORITHM& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_ALGORITHM(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_ALGORITHM(
std::string* buffer,
TPMA_ALGORITHM* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_OBJECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_OBJECT(
const TPMA_OBJECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_OBJECT(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_OBJECT(
std::string* buffer,
TPMA_OBJECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_SESSION(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_SESSION(
const TPMA_SESSION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_SESSION(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_SESSION(
std::string* buffer,
TPMA_SESSION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_LOCALITY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_LOCALITY(
const TPMA_LOCALITY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_LOCALITY(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_LOCALITY(
std::string* buffer,
TPMA_LOCALITY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_PERMANENT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_PERMANENT(
const TPMA_PERMANENT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_PERMANENT(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_PERMANENT(
std::string* buffer,
TPMA_PERMANENT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_STARTUP_CLEAR(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_STARTUP_CLEAR(
const TPMA_STARTUP_CLEAR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_STARTUP_CLEAR(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_STARTUP_CLEAR(
std::string* buffer,
TPMA_STARTUP_CLEAR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_MEMORY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_MEMORY(
const TPMA_MEMORY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_MEMORY(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_MEMORY(
std::string* buffer,
TPMA_MEMORY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_CC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_CC(
const TPMA_CC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_CC(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_CC(
std::string* buffer,
TPMA_CC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_NV_INDEX(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_NV_INDEX(
const TPM_NV_INDEX& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_NV_INDEX(
+TRUNKS_EXPORT TPM_RC Parse_TPM_NV_INDEX(
std::string* buffer,
TPM_NV_INDEX* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMA_NV(
+TRUNKS_EXPORT TPM_RC Serialize_TPMA_NV(
const TPMA_NV& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMA_NV(
+TRUNKS_EXPORT TPM_RC Parse_TPMA_NV(
std::string* buffer,
TPMA_NV* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_SPEC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_SPEC(
const TPM_SPEC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_SPEC(
+TRUNKS_EXPORT TPM_RC Parse_TPM_SPEC(
std::string* buffer,
TPM_SPEC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_GENERATED(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_GENERATED(
const TPM_GENERATED& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_GENERATED(
+TRUNKS_EXPORT TPM_RC Parse_TPM_GENERATED(
std::string* buffer,
TPM_GENERATED* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_ALG_ID(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_ALG_ID(
const TPM_ALG_ID& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_ALG_ID(
+TRUNKS_EXPORT TPM_RC Parse_TPM_ALG_ID(
std::string* buffer,
TPM_ALG_ID* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_ECC_CURVE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_ECC_CURVE(
const TPM_ECC_CURVE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_ECC_CURVE(
+TRUNKS_EXPORT TPM_RC Parse_TPM_ECC_CURVE(
std::string* buffer,
TPM_ECC_CURVE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_CC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_CC(
const TPM_CC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_CC(
+TRUNKS_EXPORT TPM_RC Parse_TPM_CC(
std::string* buffer,
TPM_CC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_RC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_RC(
const TPM_RC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_RC(
+TRUNKS_EXPORT TPM_RC Parse_TPM_RC(
std::string* buffer,
TPM_RC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_CLOCK_ADJUST(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_CLOCK_ADJUST(
const TPM_CLOCK_ADJUST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_CLOCK_ADJUST(
+TRUNKS_EXPORT TPM_RC Parse_TPM_CLOCK_ADJUST(
std::string* buffer,
TPM_CLOCK_ADJUST* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_EO(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_EO(
const TPM_EO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_EO(
+TRUNKS_EXPORT TPM_RC Parse_TPM_EO(
std::string* buffer,
TPM_EO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_ST(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_ST(
const TPM_ST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_ST(
+TRUNKS_EXPORT TPM_RC Parse_TPM_ST(
std::string* buffer,
TPM_ST* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_SU(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_SU(
const TPM_SU& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_SU(
+TRUNKS_EXPORT TPM_RC Parse_TPM_SU(
std::string* buffer,
TPM_SU* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_SE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_SE(
const TPM_SE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_SE(
+TRUNKS_EXPORT TPM_RC Parse_TPM_SE(
std::string* buffer,
TPM_SE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_CAP(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_CAP(
const TPM_CAP& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_CAP(
+TRUNKS_EXPORT TPM_RC Parse_TPM_CAP(
std::string* buffer,
TPM_CAP* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_PT(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_PT(
const TPM_PT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_PT(
+TRUNKS_EXPORT TPM_RC Parse_TPM_PT(
std::string* buffer,
TPM_PT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_PT_PCR(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_PT_PCR(
const TPM_PT_PCR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_PT_PCR(
+TRUNKS_EXPORT TPM_RC Parse_TPM_PT_PCR(
std::string* buffer,
TPM_PT_PCR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_PS(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_PS(
const TPM_PS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_PS(
+TRUNKS_EXPORT TPM_RC Parse_TPM_PS(
std::string* buffer,
TPM_PS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_HT(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_HT(
const TPM_HT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_HT(
+TRUNKS_EXPORT TPM_RC Parse_TPM_HT(
std::string* buffer,
TPM_HT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_RH(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_RH(
const TPM_RH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_RH(
+TRUNKS_EXPORT TPM_RC Parse_TPM_RH(
std::string* buffer,
TPM_RH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM_HC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM_HC(
const TPM_HC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM_HC(
+TRUNKS_EXPORT TPM_RC Parse_TPM_HC(
std::string* buffer,
TPM_HC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ALGORITHM_DESCRIPTION(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ALGORITHM_DESCRIPTION(
const TPMS_ALGORITHM_DESCRIPTION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ALGORITHM_DESCRIPTION(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ALGORITHM_DESCRIPTION(
std::string* buffer,
TPMS_ALGORITHM_DESCRIPTION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_HA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_HA(
const TPMT_HA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_HA(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_HA(
std::string* buffer,
TPMT_HA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_DIGEST(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_DIGEST(
const TPM2B_DIGEST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_DIGEST(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_DIGEST(
std::string* buffer,
TPM2B_DIGEST* value,
std::string* value_bytes);
-TPM2B_DIGEST CHROMEOS_EXPORT Make_TPM2B_DIGEST(
+TRUNKS_EXPORT TPM2B_DIGEST Make_TPM2B_DIGEST(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_DIGEST(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_DIGEST(
const TPM2B_DIGEST& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_DATA(
const TPM2B_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_DATA(
std::string* buffer,
TPM2B_DATA* value,
std::string* value_bytes);
-TPM2B_DATA CHROMEOS_EXPORT Make_TPM2B_DATA(
+TRUNKS_EXPORT TPM2B_DATA Make_TPM2B_DATA(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_DATA(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_DATA(
const TPM2B_DATA& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_EVENT(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_EVENT(
const TPM2B_EVENT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_EVENT(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_EVENT(
std::string* buffer,
TPM2B_EVENT* value,
std::string* value_bytes);
-TPM2B_EVENT CHROMEOS_EXPORT Make_TPM2B_EVENT(
+TRUNKS_EXPORT TPM2B_EVENT Make_TPM2B_EVENT(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_EVENT(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_EVENT(
const TPM2B_EVENT& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_MAX_BUFFER(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_MAX_BUFFER(
const TPM2B_MAX_BUFFER& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_MAX_BUFFER(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_MAX_BUFFER(
std::string* buffer,
TPM2B_MAX_BUFFER* value,
std::string* value_bytes);
-TPM2B_MAX_BUFFER CHROMEOS_EXPORT Make_TPM2B_MAX_BUFFER(
+TRUNKS_EXPORT TPM2B_MAX_BUFFER Make_TPM2B_MAX_BUFFER(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_MAX_BUFFER(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_MAX_BUFFER(
const TPM2B_MAX_BUFFER& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_MAX_NV_BUFFER(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_MAX_NV_BUFFER(
const TPM2B_MAX_NV_BUFFER& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_MAX_NV_BUFFER(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_MAX_NV_BUFFER(
std::string* buffer,
TPM2B_MAX_NV_BUFFER* value,
std::string* value_bytes);
-TPM2B_MAX_NV_BUFFER CHROMEOS_EXPORT Make_TPM2B_MAX_NV_BUFFER(
+TRUNKS_EXPORT TPM2B_MAX_NV_BUFFER Make_TPM2B_MAX_NV_BUFFER(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_MAX_NV_BUFFER(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_MAX_NV_BUFFER(
const TPM2B_MAX_NV_BUFFER& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_TIMEOUT(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_TIMEOUT(
const TPM2B_TIMEOUT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_TIMEOUT(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_TIMEOUT(
std::string* buffer,
TPM2B_TIMEOUT* value,
std::string* value_bytes);
-TPM2B_TIMEOUT CHROMEOS_EXPORT Make_TPM2B_TIMEOUT(
+TRUNKS_EXPORT TPM2B_TIMEOUT Make_TPM2B_TIMEOUT(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_TIMEOUT(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_TIMEOUT(
const TPM2B_TIMEOUT& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_IV(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_IV(
const TPM2B_IV& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_IV(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_IV(
std::string* buffer,
TPM2B_IV* value,
std::string* value_bytes);
-TPM2B_IV CHROMEOS_EXPORT Make_TPM2B_IV(
+TRUNKS_EXPORT TPM2B_IV Make_TPM2B_IV(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_IV(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_IV(
const TPM2B_IV& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_NAME(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_NAME(
const TPM2B_NAME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_NAME(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_NAME(
std::string* buffer,
TPM2B_NAME* value,
std::string* value_bytes);
-TPM2B_NAME CHROMEOS_EXPORT Make_TPM2B_NAME(
+TRUNKS_EXPORT TPM2B_NAME Make_TPM2B_NAME(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_NAME(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_NAME(
const TPM2B_NAME& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_PCR_SELECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_PCR_SELECT(
const TPMS_PCR_SELECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_PCR_SELECT(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_PCR_SELECT(
std::string* buffer,
TPMS_PCR_SELECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_PCR_SELECTION(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_PCR_SELECTION(
const TPMS_PCR_SELECTION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_PCR_SELECTION(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_PCR_SELECTION(
std::string* buffer,
TPMS_PCR_SELECTION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_TK_CREATION(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_TK_CREATION(
const TPMT_TK_CREATION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_TK_CREATION(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_TK_CREATION(
std::string* buffer,
TPMT_TK_CREATION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_TK_VERIFIED(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_TK_VERIFIED(
const TPMT_TK_VERIFIED& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_TK_VERIFIED(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_TK_VERIFIED(
std::string* buffer,
TPMT_TK_VERIFIED* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_TK_AUTH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_TK_AUTH(
const TPMT_TK_AUTH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_TK_AUTH(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_TK_AUTH(
std::string* buffer,
TPMT_TK_AUTH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_TK_HASHCHECK(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_TK_HASHCHECK(
const TPMT_TK_HASHCHECK& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_TK_HASHCHECK(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_TK_HASHCHECK(
std::string* buffer,
TPMT_TK_HASHCHECK* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ALG_PROPERTY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ALG_PROPERTY(
const TPMS_ALG_PROPERTY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ALG_PROPERTY(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ALG_PROPERTY(
std::string* buffer,
TPMS_ALG_PROPERTY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_TAGGED_PROPERTY(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_TAGGED_PROPERTY(
const TPMS_TAGGED_PROPERTY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_TAGGED_PROPERTY(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_TAGGED_PROPERTY(
std::string* buffer,
TPMS_TAGGED_PROPERTY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_TAGGED_PCR_SELECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_TAGGED_PCR_SELECT(
const TPMS_TAGGED_PCR_SELECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_TAGGED_PCR_SELECT(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_TAGGED_PCR_SELECT(
std::string* buffer,
TPMS_TAGGED_PCR_SELECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_CC(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_CC(
const TPML_CC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_CC(
+TRUNKS_EXPORT TPM_RC Parse_TPML_CC(
std::string* buffer,
TPML_CC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_CCA(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_CCA(
const TPML_CCA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_CCA(
+TRUNKS_EXPORT TPM_RC Parse_TPML_CCA(
std::string* buffer,
TPML_CCA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_ALG(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_ALG(
const TPML_ALG& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_ALG(
+TRUNKS_EXPORT TPM_RC Parse_TPML_ALG(
std::string* buffer,
TPML_ALG* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_HANDLE(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_HANDLE(
const TPML_HANDLE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_HANDLE(
+TRUNKS_EXPORT TPM_RC Parse_TPML_HANDLE(
std::string* buffer,
TPML_HANDLE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_DIGEST(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_DIGEST(
const TPML_DIGEST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_DIGEST(
+TRUNKS_EXPORT TPM_RC Parse_TPML_DIGEST(
std::string* buffer,
TPML_DIGEST* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_DIGEST_VALUES(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_DIGEST_VALUES(
const TPML_DIGEST_VALUES& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_DIGEST_VALUES(
+TRUNKS_EXPORT TPM_RC Parse_TPML_DIGEST_VALUES(
std::string* buffer,
TPML_DIGEST_VALUES* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_DIGEST_VALUES(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_DIGEST_VALUES(
const TPM2B_DIGEST_VALUES& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_DIGEST_VALUES(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_DIGEST_VALUES(
std::string* buffer,
TPM2B_DIGEST_VALUES* value,
std::string* value_bytes);
-TPM2B_DIGEST_VALUES CHROMEOS_EXPORT Make_TPM2B_DIGEST_VALUES(
+TRUNKS_EXPORT TPM2B_DIGEST_VALUES Make_TPM2B_DIGEST_VALUES(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_DIGEST_VALUES(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_DIGEST_VALUES(
const TPM2B_DIGEST_VALUES& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_PCR_SELECTION(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_PCR_SELECTION(
const TPML_PCR_SELECTION& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_PCR_SELECTION(
+TRUNKS_EXPORT TPM_RC Parse_TPML_PCR_SELECTION(
std::string* buffer,
TPML_PCR_SELECTION* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_ALG_PROPERTY(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_ALG_PROPERTY(
const TPML_ALG_PROPERTY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_ALG_PROPERTY(
+TRUNKS_EXPORT TPM_RC Parse_TPML_ALG_PROPERTY(
std::string* buffer,
TPML_ALG_PROPERTY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_TAGGED_TPM_PROPERTY(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_TAGGED_TPM_PROPERTY(
const TPML_TAGGED_TPM_PROPERTY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_TAGGED_TPM_PROPERTY(
+TRUNKS_EXPORT TPM_RC Parse_TPML_TAGGED_TPM_PROPERTY(
std::string* buffer,
TPML_TAGGED_TPM_PROPERTY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_TAGGED_PCR_PROPERTY(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_TAGGED_PCR_PROPERTY(
const TPML_TAGGED_PCR_PROPERTY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_TAGGED_PCR_PROPERTY(
+TRUNKS_EXPORT TPM_RC Parse_TPML_TAGGED_PCR_PROPERTY(
std::string* buffer,
TPML_TAGGED_PCR_PROPERTY* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPML_ECC_CURVE(
+TRUNKS_EXPORT TPM_RC Serialize_TPML_ECC_CURVE(
const TPML_ECC_CURVE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPML_ECC_CURVE(
+TRUNKS_EXPORT TPM_RC Parse_TPML_ECC_CURVE(
std::string* buffer,
TPML_ECC_CURVE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CAPABILITY_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CAPABILITY_DATA(
const TPMS_CAPABILITY_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CAPABILITY_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CAPABILITY_DATA(
std::string* buffer,
TPMS_CAPABILITY_DATA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CLOCK_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CLOCK_INFO(
const TPMS_CLOCK_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CLOCK_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CLOCK_INFO(
std::string* buffer,
TPMS_CLOCK_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_TIME_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_TIME_INFO(
const TPMS_TIME_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_TIME_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_TIME_INFO(
std::string* buffer,
TPMS_TIME_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_TIME_ATTEST_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_TIME_ATTEST_INFO(
const TPMS_TIME_ATTEST_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_TIME_ATTEST_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_TIME_ATTEST_INFO(
std::string* buffer,
TPMS_TIME_ATTEST_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CERTIFY_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CERTIFY_INFO(
const TPMS_CERTIFY_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CERTIFY_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CERTIFY_INFO(
std::string* buffer,
TPMS_CERTIFY_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_QUOTE_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_QUOTE_INFO(
const TPMS_QUOTE_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_QUOTE_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_QUOTE_INFO(
std::string* buffer,
TPMS_QUOTE_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_COMMAND_AUDIT_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_COMMAND_AUDIT_INFO(
const TPMS_COMMAND_AUDIT_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_COMMAND_AUDIT_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_COMMAND_AUDIT_INFO(
std::string* buffer,
TPMS_COMMAND_AUDIT_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SESSION_AUDIT_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SESSION_AUDIT_INFO(
const TPMS_SESSION_AUDIT_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SESSION_AUDIT_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SESSION_AUDIT_INFO(
std::string* buffer,
TPMS_SESSION_AUDIT_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CREATION_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CREATION_INFO(
const TPMS_CREATION_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CREATION_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CREATION_INFO(
std::string* buffer,
TPMS_CREATION_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_NV_CERTIFY_INFO(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_NV_CERTIFY_INFO(
const TPMS_NV_CERTIFY_INFO& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_NV_CERTIFY_INFO(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_NV_CERTIFY_INFO(
std::string* buffer,
TPMS_NV_CERTIFY_INFO* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ATTEST(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ATTEST(
const TPMS_ATTEST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ATTEST(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ATTEST(
std::string* buffer,
TPMS_ATTEST* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_ATTEST(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_ATTEST(
const TPM2B_ATTEST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_ATTEST(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_ATTEST(
std::string* buffer,
TPM2B_ATTEST* value,
std::string* value_bytes);
-TPM2B_ATTEST CHROMEOS_EXPORT Make_TPM2B_ATTEST(
+TRUNKS_EXPORT TPM2B_ATTEST Make_TPM2B_ATTEST(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_ATTEST(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_ATTEST(
const TPM2B_ATTEST& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_AUTH_COMMAND(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_AUTH_COMMAND(
const TPMS_AUTH_COMMAND& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_AUTH_COMMAND(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_AUTH_COMMAND(
std::string* buffer,
TPMS_AUTH_COMMAND* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_AUTH_RESPONSE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_AUTH_RESPONSE(
const TPMS_AUTH_RESPONSE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_AUTH_RESPONSE(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_AUTH_RESPONSE(
std::string* buffer,
TPMS_AUTH_RESPONSE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_SYM_DEF(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_SYM_DEF(
const TPMT_SYM_DEF& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_SYM_DEF(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_SYM_DEF(
std::string* buffer,
TPMT_SYM_DEF* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_SYM_DEF_OBJECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_SYM_DEF_OBJECT(
const TPMT_SYM_DEF_OBJECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_SYM_DEF_OBJECT(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_SYM_DEF_OBJECT(
std::string* buffer,
TPMT_SYM_DEF_OBJECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_SYM_KEY(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_SYM_KEY(
const TPM2B_SYM_KEY& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_SYM_KEY(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_SYM_KEY(
std::string* buffer,
TPM2B_SYM_KEY* value,
std::string* value_bytes);
-TPM2B_SYM_KEY CHROMEOS_EXPORT Make_TPM2B_SYM_KEY(
+TRUNKS_EXPORT TPM2B_SYM_KEY Make_TPM2B_SYM_KEY(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_SYM_KEY(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_SYM_KEY(
const TPM2B_SYM_KEY& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SYMCIPHER_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SYMCIPHER_PARMS(
const TPMS_SYMCIPHER_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SYMCIPHER_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SYMCIPHER_PARMS(
std::string* buffer,
TPMS_SYMCIPHER_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_SENSITIVE_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_SENSITIVE_DATA(
const TPM2B_SENSITIVE_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_SENSITIVE_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_SENSITIVE_DATA(
std::string* buffer,
TPM2B_SENSITIVE_DATA* value,
std::string* value_bytes);
-TPM2B_SENSITIVE_DATA CHROMEOS_EXPORT Make_TPM2B_SENSITIVE_DATA(
+TRUNKS_EXPORT TPM2B_SENSITIVE_DATA Make_TPM2B_SENSITIVE_DATA(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_SENSITIVE_DATA(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_SENSITIVE_DATA(
const TPM2B_SENSITIVE_DATA& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SENSITIVE_CREATE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SENSITIVE_CREATE(
const TPMS_SENSITIVE_CREATE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SENSITIVE_CREATE(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SENSITIVE_CREATE(
std::string* buffer,
TPMS_SENSITIVE_CREATE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_SENSITIVE_CREATE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_SENSITIVE_CREATE(
const TPM2B_SENSITIVE_CREATE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_SENSITIVE_CREATE(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_SENSITIVE_CREATE(
std::string* buffer,
TPM2B_SENSITIVE_CREATE* value,
std::string* value_bytes);
-TPM2B_SENSITIVE_CREATE CHROMEOS_EXPORT Make_TPM2B_SENSITIVE_CREATE(
+TRUNKS_EXPORT TPM2B_SENSITIVE_CREATE Make_TPM2B_SENSITIVE_CREATE(
const TPMS_SENSITIVE_CREATE& inner);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_SIGHASH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_SIGHASH(
const TPMS_SCHEME_SIGHASH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_SIGHASH(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_SIGHASH(
std::string* buffer,
TPMS_SCHEME_SIGHASH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_XOR(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_XOR(
const TPMS_SCHEME_XOR& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_XOR(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_XOR(
std::string* buffer,
TPMS_SCHEME_XOR* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_KEYEDHASH_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_KEYEDHASH_SCHEME(
const TPMT_KEYEDHASH_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_KEYEDHASH_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_KEYEDHASH_SCHEME(
std::string* buffer,
TPMT_KEYEDHASH_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_ECDAA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_ECDAA(
const TPMS_SCHEME_ECDAA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_ECDAA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_ECDAA(
std::string* buffer,
TPMS_SCHEME_ECDAA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_SIG_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_SIG_SCHEME(
const TPMT_SIG_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_SIG_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_SIG_SCHEME(
std::string* buffer,
TPMT_SIG_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_OAEP(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_OAEP(
const TPMS_SCHEME_OAEP& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_OAEP(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_OAEP(
std::string* buffer,
TPMS_SCHEME_OAEP* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_ECDH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_ECDH(
const TPMS_SCHEME_ECDH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_ECDH(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_ECDH(
std::string* buffer,
TPMS_SCHEME_ECDH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_MGF1(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_MGF1(
const TPMS_SCHEME_MGF1& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_MGF1(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_MGF1(
std::string* buffer,
TPMS_SCHEME_MGF1* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_KDF1_SP800_56a(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_KDF1_SP800_56a(
const TPMS_SCHEME_KDF1_SP800_56a& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_KDF1_SP800_56a(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_KDF1_SP800_56a(
std::string* buffer,
TPMS_SCHEME_KDF1_SP800_56a* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_KDF2(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_KDF2(
const TPMS_SCHEME_KDF2& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_KDF2(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_KDF2(
std::string* buffer,
TPMS_SCHEME_KDF2* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SCHEME_KDF1_SP800_108(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SCHEME_KDF1_SP800_108(
const TPMS_SCHEME_KDF1_SP800_108& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SCHEME_KDF1_SP800_108(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SCHEME_KDF1_SP800_108(
std::string* buffer,
TPMS_SCHEME_KDF1_SP800_108* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_KDF_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_KDF_SCHEME(
const TPMT_KDF_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_KDF_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_KDF_SCHEME(
std::string* buffer,
TPMT_KDF_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_ASYM_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_ASYM_SCHEME(
const TPMT_ASYM_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_ASYM_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_ASYM_SCHEME(
std::string* buffer,
TPMT_ASYM_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_RSA_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_RSA_SCHEME(
const TPMT_RSA_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_RSA_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_RSA_SCHEME(
std::string* buffer,
TPMT_RSA_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_RSA_DECRYPT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_RSA_DECRYPT(
const TPMT_RSA_DECRYPT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_RSA_DECRYPT(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_RSA_DECRYPT(
std::string* buffer,
TPMT_RSA_DECRYPT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_PUBLIC_KEY_RSA(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_PUBLIC_KEY_RSA(
const TPM2B_PUBLIC_KEY_RSA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_PUBLIC_KEY_RSA(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_PUBLIC_KEY_RSA(
std::string* buffer,
TPM2B_PUBLIC_KEY_RSA* value,
std::string* value_bytes);
-TPM2B_PUBLIC_KEY_RSA CHROMEOS_EXPORT Make_TPM2B_PUBLIC_KEY_RSA(
+TRUNKS_EXPORT TPM2B_PUBLIC_KEY_RSA Make_TPM2B_PUBLIC_KEY_RSA(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_PUBLIC_KEY_RSA(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_PUBLIC_KEY_RSA(
const TPM2B_PUBLIC_KEY_RSA& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_PRIVATE_KEY_RSA(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_PRIVATE_KEY_RSA(
const TPM2B_PRIVATE_KEY_RSA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_PRIVATE_KEY_RSA(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_PRIVATE_KEY_RSA(
std::string* buffer,
TPM2B_PRIVATE_KEY_RSA* value,
std::string* value_bytes);
-TPM2B_PRIVATE_KEY_RSA CHROMEOS_EXPORT Make_TPM2B_PRIVATE_KEY_RSA(
+TRUNKS_EXPORT TPM2B_PRIVATE_KEY_RSA Make_TPM2B_PRIVATE_KEY_RSA(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_PRIVATE_KEY_RSA(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_PRIVATE_KEY_RSA(
const TPM2B_PRIVATE_KEY_RSA& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_ECC_PARAMETER(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_ECC_PARAMETER(
const TPM2B_ECC_PARAMETER& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_ECC_PARAMETER(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_ECC_PARAMETER(
std::string* buffer,
TPM2B_ECC_PARAMETER* value,
std::string* value_bytes);
-TPM2B_ECC_PARAMETER CHROMEOS_EXPORT Make_TPM2B_ECC_PARAMETER(
+TRUNKS_EXPORT TPM2B_ECC_PARAMETER Make_TPM2B_ECC_PARAMETER(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_ECC_PARAMETER(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_ECC_PARAMETER(
const TPM2B_ECC_PARAMETER& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ECC_POINT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ECC_POINT(
const TPMS_ECC_POINT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ECC_POINT(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ECC_POINT(
std::string* buffer,
TPMS_ECC_POINT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_ECC_POINT(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_ECC_POINT(
const TPM2B_ECC_POINT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_ECC_POINT(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_ECC_POINT(
std::string* buffer,
TPM2B_ECC_POINT* value,
std::string* value_bytes);
-TPM2B_ECC_POINT CHROMEOS_EXPORT Make_TPM2B_ECC_POINT(
+TRUNKS_EXPORT TPM2B_ECC_POINT Make_TPM2B_ECC_POINT(
const TPMS_ECC_POINT& inner);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_ECC_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_ECC_SCHEME(
const TPMT_ECC_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_ECC_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_ECC_SCHEME(
std::string* buffer,
TPMT_ECC_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ALGORITHM_DETAIL_ECC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ALGORITHM_DETAIL_ECC(
const TPMS_ALGORITHM_DETAIL_ECC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ALGORITHM_DETAIL_ECC(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ALGORITHM_DETAIL_ECC(
std::string* buffer,
TPMS_ALGORITHM_DETAIL_ECC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SIGNATURE_RSASSA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SIGNATURE_RSASSA(
const TPMS_SIGNATURE_RSASSA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SIGNATURE_RSASSA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SIGNATURE_RSASSA(
std::string* buffer,
TPMS_SIGNATURE_RSASSA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SIGNATURE_RSAPSS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SIGNATURE_RSAPSS(
const TPMS_SIGNATURE_RSAPSS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SIGNATURE_RSAPSS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SIGNATURE_RSAPSS(
std::string* buffer,
TPMS_SIGNATURE_RSAPSS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_SIGNATURE_ECDSA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_SIGNATURE_ECDSA(
const TPMS_SIGNATURE_ECDSA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_SIGNATURE_ECDSA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_SIGNATURE_ECDSA(
std::string* buffer,
TPMS_SIGNATURE_ECDSA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_SIGNATURE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_SIGNATURE(
const TPMT_SIGNATURE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_SIGNATURE(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_SIGNATURE(
std::string* buffer,
TPMT_SIGNATURE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_ENCRYPTED_SECRET(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_ENCRYPTED_SECRET(
const TPM2B_ENCRYPTED_SECRET& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_ENCRYPTED_SECRET(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_ENCRYPTED_SECRET(
std::string* buffer,
TPM2B_ENCRYPTED_SECRET* value,
std::string* value_bytes);
-TPM2B_ENCRYPTED_SECRET CHROMEOS_EXPORT Make_TPM2B_ENCRYPTED_SECRET(
+TRUNKS_EXPORT TPM2B_ENCRYPTED_SECRET Make_TPM2B_ENCRYPTED_SECRET(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_ENCRYPTED_SECRET(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_ENCRYPTED_SECRET(
const TPM2B_ENCRYPTED_SECRET& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_KEYEDHASH_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_KEYEDHASH_PARMS(
const TPMS_KEYEDHASH_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_KEYEDHASH_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_KEYEDHASH_PARMS(
std::string* buffer,
TPMS_KEYEDHASH_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ASYM_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ASYM_PARMS(
const TPMS_ASYM_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ASYM_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ASYM_PARMS(
std::string* buffer,
TPMS_ASYM_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_RSA_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_RSA_PARMS(
const TPMS_RSA_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_RSA_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_RSA_PARMS(
std::string* buffer,
TPMS_RSA_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_ECC_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_ECC_PARMS(
const TPMS_ECC_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_ECC_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_ECC_PARMS(
std::string* buffer,
TPMS_ECC_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_PUBLIC_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_PUBLIC_PARMS(
const TPMT_PUBLIC_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_PUBLIC_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_PUBLIC_PARMS(
std::string* buffer,
TPMT_PUBLIC_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_PUBLIC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_PUBLIC(
const TPMT_PUBLIC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_PUBLIC(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_PUBLIC(
std::string* buffer,
TPMT_PUBLIC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_PUBLIC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_PUBLIC(
const TPM2B_PUBLIC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_PUBLIC(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_PUBLIC(
std::string* buffer,
TPM2B_PUBLIC* value,
std::string* value_bytes);
-TPM2B_PUBLIC CHROMEOS_EXPORT Make_TPM2B_PUBLIC(
+TRUNKS_EXPORT TPM2B_PUBLIC Make_TPM2B_PUBLIC(
const TPMT_PUBLIC& inner);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_PRIVATE_VENDOR_SPECIFIC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_PRIVATE_VENDOR_SPECIFIC(
const TPM2B_PRIVATE_VENDOR_SPECIFIC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_PRIVATE_VENDOR_SPECIFIC(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_PRIVATE_VENDOR_SPECIFIC(
std::string* buffer,
TPM2B_PRIVATE_VENDOR_SPECIFIC* value,
std::string* value_bytes);
-TPM2B_PRIVATE_VENDOR_SPECIFIC CHROMEOS_EXPORT Make_TPM2B_PRIVATE_VENDOR_SPECIFIC(
+TRUNKS_EXPORT TPM2B_PRIVATE_VENDOR_SPECIFIC Make_TPM2B_PRIVATE_VENDOR_SPECIFIC(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_PRIVATE_VENDOR_SPECIFIC(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_PRIVATE_VENDOR_SPECIFIC(
const TPM2B_PRIVATE_VENDOR_SPECIFIC& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMT_SENSITIVE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMT_SENSITIVE(
const TPMT_SENSITIVE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMT_SENSITIVE(
+TRUNKS_EXPORT TPM_RC Parse_TPMT_SENSITIVE(
std::string* buffer,
TPMT_SENSITIVE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_SENSITIVE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_SENSITIVE(
const TPM2B_SENSITIVE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_SENSITIVE(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_SENSITIVE(
std::string* buffer,
TPM2B_SENSITIVE* value,
std::string* value_bytes);
-TPM2B_SENSITIVE CHROMEOS_EXPORT Make_TPM2B_SENSITIVE(
+TRUNKS_EXPORT TPM2B_SENSITIVE Make_TPM2B_SENSITIVE(
const TPMT_SENSITIVE& inner);
-TPM_RC CHROMEOS_EXPORT Serialize__PRIVATE(
+TRUNKS_EXPORT TPM_RC Serialize__PRIVATE(
const _PRIVATE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse__PRIVATE(
+TRUNKS_EXPORT TPM_RC Parse__PRIVATE(
std::string* buffer,
_PRIVATE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_PRIVATE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_PRIVATE(
const TPM2B_PRIVATE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_PRIVATE(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_PRIVATE(
std::string* buffer,
TPM2B_PRIVATE* value,
std::string* value_bytes);
-TPM2B_PRIVATE CHROMEOS_EXPORT Make_TPM2B_PRIVATE(
+TRUNKS_EXPORT TPM2B_PRIVATE Make_TPM2B_PRIVATE(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_PRIVATE(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_PRIVATE(
const TPM2B_PRIVATE& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize__ID_OBJECT(
+TRUNKS_EXPORT TPM_RC Serialize__ID_OBJECT(
const _ID_OBJECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse__ID_OBJECT(
+TRUNKS_EXPORT TPM_RC Parse__ID_OBJECT(
std::string* buffer,
_ID_OBJECT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_ID_OBJECT(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_ID_OBJECT(
const TPM2B_ID_OBJECT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_ID_OBJECT(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_ID_OBJECT(
std::string* buffer,
TPM2B_ID_OBJECT* value,
std::string* value_bytes);
-TPM2B_ID_OBJECT CHROMEOS_EXPORT Make_TPM2B_ID_OBJECT(
+TRUNKS_EXPORT TPM2B_ID_OBJECT Make_TPM2B_ID_OBJECT(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_ID_OBJECT(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_ID_OBJECT(
const TPM2B_ID_OBJECT& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_NV_PUBLIC(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_NV_PUBLIC(
const TPMS_NV_PUBLIC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_NV_PUBLIC(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_NV_PUBLIC(
std::string* buffer,
TPMS_NV_PUBLIC* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_NV_PUBLIC(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_NV_PUBLIC(
const TPM2B_NV_PUBLIC& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_NV_PUBLIC(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_NV_PUBLIC(
std::string* buffer,
TPM2B_NV_PUBLIC* value,
std::string* value_bytes);
-TPM2B_NV_PUBLIC CHROMEOS_EXPORT Make_TPM2B_NV_PUBLIC(
+TRUNKS_EXPORT TPM2B_NV_PUBLIC Make_TPM2B_NV_PUBLIC(
const TPMS_NV_PUBLIC& inner);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_CONTEXT_SENSITIVE(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_CONTEXT_SENSITIVE(
const TPM2B_CONTEXT_SENSITIVE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_CONTEXT_SENSITIVE(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_CONTEXT_SENSITIVE(
std::string* buffer,
TPM2B_CONTEXT_SENSITIVE* value,
std::string* value_bytes);
-TPM2B_CONTEXT_SENSITIVE CHROMEOS_EXPORT Make_TPM2B_CONTEXT_SENSITIVE(
+TRUNKS_EXPORT TPM2B_CONTEXT_SENSITIVE Make_TPM2B_CONTEXT_SENSITIVE(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_CONTEXT_SENSITIVE(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_CONTEXT_SENSITIVE(
const TPM2B_CONTEXT_SENSITIVE& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CONTEXT_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CONTEXT_DATA(
const TPMS_CONTEXT_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CONTEXT_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CONTEXT_DATA(
std::string* buffer,
TPMS_CONTEXT_DATA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_CONTEXT_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_CONTEXT_DATA(
const TPM2B_CONTEXT_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_CONTEXT_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_CONTEXT_DATA(
std::string* buffer,
TPM2B_CONTEXT_DATA* value,
std::string* value_bytes);
-TPM2B_CONTEXT_DATA CHROMEOS_EXPORT Make_TPM2B_CONTEXT_DATA(
+TRUNKS_EXPORT TPM2B_CONTEXT_DATA Make_TPM2B_CONTEXT_DATA(
const std::string& bytes);
-std::string CHROMEOS_EXPORT StringFrom_TPM2B_CONTEXT_DATA(
+TRUNKS_EXPORT std::string StringFrom_TPM2B_CONTEXT_DATA(
const TPM2B_CONTEXT_DATA& tpm2b);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CONTEXT(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CONTEXT(
const TPMS_CONTEXT& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CONTEXT(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CONTEXT(
std::string* buffer,
TPMS_CONTEXT* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMS_CREATION_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMS_CREATION_DATA(
const TPMS_CREATION_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMS_CREATION_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPMS_CREATION_DATA(
std::string* buffer,
TPMS_CREATION_DATA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPM2B_CREATION_DATA(
+TRUNKS_EXPORT TPM_RC Serialize_TPM2B_CREATION_DATA(
const TPM2B_CREATION_DATA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPM2B_CREATION_DATA(
+TRUNKS_EXPORT TPM_RC Parse_TPM2B_CREATION_DATA(
std::string* buffer,
TPM2B_CREATION_DATA* value,
std::string* value_bytes);
-TPM2B_CREATION_DATA CHROMEOS_EXPORT Make_TPM2B_CREATION_DATA(
+TRUNKS_EXPORT TPM2B_CREATION_DATA Make_TPM2B_CREATION_DATA(
const TPMS_CREATION_DATA& inner);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_HA(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_HA(
const TPMU_HA& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_HA(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_HA(
std::string* buffer,
TPMU_HA* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_NAME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_NAME(
const TPMU_NAME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_NAME(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_NAME(
std::string* buffer,
TPMU_NAME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_CAPABILITIES(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_CAPABILITIES(
const TPMU_CAPABILITIES& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_CAPABILITIES(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_CAPABILITIES(
std::string* buffer,
TPMU_CAPABILITIES* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_ATTEST(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_ATTEST(
const TPMU_ATTEST& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_ATTEST(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_ATTEST(
std::string* buffer,
TPMU_ATTEST* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SYM_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SYM_KEY_BITS(
const TPMU_SYM_KEY_BITS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SYM_KEY_BITS(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SYM_KEY_BITS(
std::string* buffer,
TPMU_SYM_KEY_BITS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SYM_MODE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SYM_MODE(
const TPMU_SYM_MODE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SYM_MODE(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SYM_MODE(
std::string* buffer,
TPMU_SYM_MODE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SCHEME_KEYEDHASH(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SCHEME_KEYEDHASH(
const TPMU_SCHEME_KEYEDHASH& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SCHEME_KEYEDHASH(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SCHEME_KEYEDHASH(
std::string* buffer,
TPMU_SCHEME_KEYEDHASH* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SIG_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SIG_SCHEME(
const TPMU_SIG_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SIG_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SIG_SCHEME(
std::string* buffer,
TPMU_SIG_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_KDF_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_KDF_SCHEME(
const TPMU_KDF_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_KDF_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_KDF_SCHEME(
std::string* buffer,
TPMU_KDF_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_ASYM_SCHEME(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_ASYM_SCHEME(
const TPMU_ASYM_SCHEME& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_ASYM_SCHEME(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_ASYM_SCHEME(
std::string* buffer,
TPMU_ASYM_SCHEME* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SIGNATURE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SIGNATURE(
const TPMU_SIGNATURE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SIGNATURE(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SIGNATURE(
std::string* buffer,
TPMU_SIGNATURE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_ENCRYPTED_SECRET(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_ENCRYPTED_SECRET(
const TPMU_ENCRYPTED_SECRET& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_ENCRYPTED_SECRET(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_ENCRYPTED_SECRET(
std::string* buffer,
TPMU_ENCRYPTED_SECRET* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_PUBLIC_ID(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_PUBLIC_ID(
const TPMU_PUBLIC_ID& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_PUBLIC_ID(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_PUBLIC_ID(
std::string* buffer,
TPMU_PUBLIC_ID* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_PUBLIC_PARMS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_PUBLIC_PARMS(
const TPMU_PUBLIC_PARMS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_PUBLIC_PARMS(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_PUBLIC_PARMS(
std::string* buffer,
TPMU_PUBLIC_PARMS* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SENSITIVE_COMPOSITE(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SENSITIVE_COMPOSITE(
const TPMU_SENSITIVE_COMPOSITE& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SENSITIVE_COMPOSITE(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SENSITIVE_COMPOSITE(
std::string* buffer,
TPMU_SENSITIVE_COMPOSITE* value,
std::string* value_bytes);
-TPM_RC CHROMEOS_EXPORT Serialize_TPMU_SYM_DETAILS(
+TRUNKS_EXPORT TPM_RC Serialize_TPMU_SYM_DETAILS(
const TPMU_SYM_DETAILS& value,
std::string* buffer);
-TPM_RC CHROMEOS_EXPORT Parse_TPMU_SYM_DETAILS(
+TRUNKS_EXPORT TPM_RC Parse_TPMU_SYM_DETAILS(
std::string* buffer,
TPMU_SYM_DETAILS* value,
std::string* value_bytes);
-class CHROMEOS_EXPORT Tpm {
+class TRUNKS_EXPORT Tpm {
public:
// Does not take ownership of |transceiver|.
explicit Tpm(CommandTransceiver* transceiver) : transceiver_(transceiver) {}
diff --git a/tpm_state.h b/tpm_state.h
index 27b2a4e..d4e009e 100644
--- a/tpm_state.h
+++ b/tpm_state.h
@@ -6,14 +6,14 @@
#define TRUNKS_TPM_STATE_H_
#include <base/macros.h>
-#include <chromeos/chromeos_export.h>
#include "trunks/tpm_generated.h"
+#include "trunks/trunks_export.h"
namespace trunks {
// TpmState is an interface which provides access to TPM state information.
-class CHROMEOS_EXPORT TpmState {
+class TRUNKS_EXPORT TpmState {
public:
TpmState() {}
virtual ~TpmState() {}
diff --git a/tpm_state_impl.h b/tpm_state_impl.h
index acf3f1e..8964c75 100644
--- a/tpm_state_impl.h
+++ b/tpm_state_impl.h
@@ -8,16 +8,16 @@
#include "trunks/tpm_state.h"
#include <base/macros.h>
-#include <chromeos/chromeos_export.h>
#include "trunks/tpm_generated.h"
+#include "trunks/trunks_export.h"
namespace trunks {
class TrunksFactory;
// TpmStateImpl is the default implementation of the TpmState interface.
-class CHROMEOS_EXPORT TpmStateImpl : public TpmState {
+class TRUNKS_EXPORT TpmStateImpl : public TpmState {
public:
explicit TpmStateImpl(const TrunksFactory& factory);
virtual ~TpmStateImpl();
diff --git a/tpm_utility.h b/tpm_utility.h
index 7aa796a..c6355a4 100644
--- a/tpm_utility.h
+++ b/tpm_utility.h
@@ -8,10 +8,10 @@
#include <string>
#include <base/macros.h>
-#include <chromeos/chromeos_export.h>
#include "trunks/authorization_session.h"
#include "trunks/tpm_generated.h"
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -21,7 +21,7 @@
const TPMI_DH_PERSISTENT kSaltingKey = PERSISTENT_FIRST + 2;
// An interface which provides convenient methods for common TPM operations.
-class CHROMEOS_EXPORT TpmUtility {
+class TRUNKS_EXPORT TpmUtility {
public:
enum AsymmetricKeyUsage {
kDecryptKey,
diff --git a/tpm_utility_impl.h b/tpm_utility_impl.h
index 8ad261f..e67b95c 100644
--- a/tpm_utility_impl.h
+++ b/tpm_utility_impl.h
@@ -11,9 +11,10 @@
#include <base/macros.h>
#include <base/memory/scoped_ptr.h>
-#include <chromeos/chromeos_export.h>
#include <gtest/gtest_prod.h>
+#include "trunks/trunks_export.h"
+
namespace trunks {
class AuthorizationDelegate;
@@ -21,7 +22,7 @@
class TrunksFactory;
// A default implementation of TpmUtility.
-class CHROMEOS_EXPORT TpmUtilityImpl : public TpmUtility {
+class TRUNKS_EXPORT TpmUtilityImpl : public TpmUtility {
public:
explicit TpmUtilityImpl(const TrunksFactory& factory);
virtual ~TpmUtilityImpl();
diff --git a/trunks_export.h b/trunks_export.h
new file mode 100644
index 0000000..4a3020f
--- /dev/null
+++ b/trunks_export.h
@@ -0,0 +1,12 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef TRUNKS_TRUNKS_EXPORT_H_
+#define TRUNKS_TRUNKS_EXPORT_H_
+
+// Use this for any class or function that needs to be exported from libtrunks.
+// E.g. TRUNKS_EXPORT void foo();
+#define TRUNKS_EXPORT __attribute__((__visibility__("default")))
+
+#endif // TRUNKS_TRUNKS_EXPORT_H_
diff --git a/trunks_factory.h b/trunks_factory.h
index ecd9744..0ca4ffc 100644
--- a/trunks_factory.h
+++ b/trunks_factory.h
@@ -9,7 +9,8 @@
#include <base/macros.h>
#include <base/memory/scoped_ptr.h>
-#include <chromeos/chromeos_export.h>
+
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -22,7 +23,7 @@
// TrunksFactory is an interface to act as a factory for trunks objects. This
// mechanism assists in injecting mocks for testing. This class is not
// thread-safe.
-class CHROMEOS_EXPORT TrunksFactory {
+class TRUNKS_EXPORT TrunksFactory {
public:
TrunksFactory() {}
virtual ~TrunksFactory() {}
diff --git a/trunks_factory_for_test.h b/trunks_factory_for_test.h
index 6616f06..5ca3383 100644
--- a/trunks_factory_for_test.h
+++ b/trunks_factory_for_test.h
@@ -11,9 +11,9 @@
#include <base/macros.h>
#include <base/memory/scoped_ptr.h>
-#include <chromeos/chromeos_export.h>
#include "trunks/password_authorization_delegate.h"
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -38,7 +38,7 @@
// MockTpmState mock_tpm_state;
// factory.set_tpm_state(mock_tpm_state);
// // Set expectations on mock_tpm_state...
-class CHROMEOS_EXPORT TrunksFactoryForTest : public TrunksFactory {
+class TRUNKS_EXPORT TrunksFactoryForTest : public TrunksFactory {
public:
TrunksFactoryForTest();
virtual ~TrunksFactoryForTest();
diff --git a/trunks_factory_impl.h b/trunks_factory_impl.h
index d96157a..127737a 100644
--- a/trunks_factory_impl.h
+++ b/trunks_factory_impl.h
@@ -11,7 +11,8 @@
#include <base/macros.h>
#include <base/memory/scoped_ptr.h>
-#include <chromeos/chromeos_export.h>
+
+#include "trunks/trunks_export.h"
namespace trunks {
@@ -19,7 +20,7 @@
class TrunksProxy;
// TrunksFactoryImpl is the default TrunksFactory implementation.
-class CHROMEOS_EXPORT TrunksFactoryImpl : public TrunksFactory {
+class TRUNKS_EXPORT TrunksFactoryImpl : public TrunksFactory {
public:
TrunksFactoryImpl();
virtual ~TrunksFactoryImpl();
diff --git a/trunks_proxy.h b/trunks_proxy.h
index 9773ea6..6009bfe 100644
--- a/trunks_proxy.h
+++ b/trunks_proxy.h
@@ -11,17 +11,18 @@
#include <base/callback.h>
#include <base/memory/weak_ptr.h>
-#include <chromeos/chromeos_export.h>
#include <dbus/bus.h>
#include <dbus/message.h>
#include <dbus/object_proxy.h>
+#include "trunks/trunks_export.h"
+
namespace trunks {
// TrunksProxy is a CommandTransceiver implementation that forwards all commands
// to the trunksd D-Bus daemon. See TrunksService for details on how the
// commands are handled once they reach trunksd.
-class CHROMEOS_EXPORT TrunksProxy: public CommandTransceiver {
+class TRUNKS_EXPORT TrunksProxy: public CommandTransceiver {
public:
TrunksProxy();
virtual ~TrunksProxy();