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();