Change crypto::tink::util::StatusOr::ValueOrDie() to value() in /tink/cc. Part of Tink migration to absl::Status{,Or}.

PiperOrigin-RevId: 436171413

6 files changed, 38 insertions, 40 deletions

diff --git a/cc/daead/aes_siv_key_manager.h b/cc/daead/aes_siv_key_manager.h
index 930f8d433..4d2429c4d 100644
--- a/cc/daead/aes_siv_key_manager.h
+++ b/cc/daead/aes_siv_key_manager.h
@@ -104,7 +104,7 @@ class AesSivKeyManager
     }
     google::crypto::tink::AesSivKey key;
     key.set_version(get_version());
-    key.set_key_value(randomness.ValueOrDie());
+    key.set_key_value(randomness.value());
     return key;
   }
 
diff --git a/cc/daead/aes_siv_key_manager_test.cc b/cc/daead/aes_siv_key_manager_test.cc
index 1e1eec504..b0e24116e 100644
--- a/cc/daead/aes_siv_key_manager_test.cc
+++ b/cc/daead/aes_siv_key_manager_test.cc
@@ -85,8 +85,8 @@ TEST(AesSivKeyManagerTest, CreateKey) {
   format.set_key_size(64);
   auto key_or = AesSivKeyManager().CreateKey(format);
   ASSERT_THAT(key_or.status(), IsOk());
-  EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(format.key_size()));
-  EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+  EXPECT_THAT(key_or.value().key_value(), SizeIs(format.key_size()));
+  EXPECT_THAT(key_or.value().version(), Eq(0));
 }
 
 TEST(AesSivKeyManagerTest, CreateKeyIsValid) {
@@ -94,7 +94,7 @@ TEST(AesSivKeyManagerTest, CreateKeyIsValid) {
   format.set_key_size(64);
   auto key_or = AesSivKeyManager().CreateKey(format);
   ASSERT_THAT(key_or.status(), IsOk());
-  EXPECT_THAT(AesSivKeyManager().ValidateKey(key_or.ValueOrDie()), IsOk());
+  EXPECT_THAT(AesSivKeyManager().ValidateKey(key_or.value()), IsOk());
 }
 
 TEST(AesSivKeyManagerTest, MultipleCreateCallsCreateDifferentKeys) {
@@ -105,8 +105,7 @@ TEST(AesSivKeyManagerTest, MultipleCreateCallsCreateDifferentKeys) {
   ASSERT_THAT(key1_or.status(), IsOk());
   auto key2_or = manager.CreateKey(format);
   ASSERT_THAT(key2_or.status(), IsOk());
-  EXPECT_THAT(key1_or.ValueOrDie().key_value(),
-              Ne(key2_or.ValueOrDie().key_value()));
+  EXPECT_THAT(key1_or.value().key_value(), Ne(key2_or.value().key_value()));
 }
 
 TEST(AesSivKeyManagerTest, DeriveKey) {
@@ -118,8 +117,8 @@ TEST(AesSivKeyManagerTest, DeriveKey) {
   auto key_or = AesSivKeyManager().DeriveKey(format, &input_stream);
 
   ASSERT_THAT(key_or.status(), IsOk());
-  EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(64));
-  EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+  EXPECT_THAT(key_or.value().key_value(), SizeIs(64));
+  EXPECT_THAT(key_or.value().version(), Eq(0));
 }
 
 TEST(AesSivKeyManagerTest, DeriveKeyFromLongSeed) {
@@ -133,7 +132,7 @@ TEST(AesSivKeyManagerTest, DeriveKeyFromLongSeed) {
 
   ASSERT_THAT(key_or.status(), IsOk());
   EXPECT_THAT(
-      key_or.ValueOrDie().key_value(),
+      key_or.value().key_value(),
       Eq("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"));
 }
 
@@ -193,21 +192,20 @@ TEST(AesSivKeyManagerTest, GetPrimitive) {
   auto key_or = AesSivKeyManager().CreateKey(format);
   ASSERT_THAT(key_or.status(), IsOk());
   auto daead_or =
-      AesSivKeyManager().GetPrimitive<DeterministicAead>(key_or.ValueOrDie());
+      AesSivKeyManager().GetPrimitive<DeterministicAead>(key_or.value());
   ASSERT_THAT(daead_or.status(), IsOk());
 
   auto direct_daead_or = subtle::AesSivBoringSsl::New(
-      util::SecretDataFromStringView(key_or.ValueOrDie().key_value()));
+      util::SecretDataFromStringView(key_or.value().key_value()));
   ASSERT_THAT(direct_daead_or.status(), IsOk());
 
   auto encryption_or =
-      daead_or.ValueOrDie()->EncryptDeterministically("123", "abcd");
+      daead_or.value()->EncryptDeterministically("123", "abcd");
   ASSERT_THAT(encryption_or.status(), IsOk());
   auto direct_encryption_or =
-      direct_daead_or.ValueOrDie()->EncryptDeterministically("123", "abcd");
+      direct_daead_or.value()->EncryptDeterministically("123", "abcd");
   ASSERT_THAT(direct_encryption_or.status(), IsOk());
-  ASSERT_THAT(encryption_or.ValueOrDie(),
-              Eq(direct_encryption_or.ValueOrDie()));
+  ASSERT_THAT(encryption_or.value(), Eq(direct_encryption_or.value()));
 }
 
 }  // namespace
diff --git a/cc/daead/deterministic_aead_config_test.cc b/cc/daead/deterministic_aead_config_test.cc
index fc280cd3f..1a59d14f5 100644
--- a/cc/daead/deterministic_aead_config_test.cc
+++ b/cc/daead/deterministic_aead_config_test.cc
@@ -82,24 +82,24 @@ TEST_F(DeterministicAeadConfigTest, WrappersRegistered) {
           primitive_set
               ->AddPrimitive(absl::make_unique<DummyDeterministicAead>("dummy"),
                              key_info)
-              .ValueOrDie()),
+              .value()),
       IsOk());
 
   auto registry_wrapped = Registry::Wrap(std::move(primitive_set));
 
   ASSERT_TRUE(registry_wrapped.ok()) << registry_wrapped.status();
   auto encryption_result =
-      registry_wrapped.ValueOrDie()->EncryptDeterministically("secret", "");
+      registry_wrapped.value()->EncryptDeterministically("secret", "");
   ASSERT_TRUE(encryption_result.ok());
 
   auto decryption_result =
       DummyDeterministicAead("dummy").DecryptDeterministically(
-          encryption_result.ValueOrDie(), "");
+          encryption_result.value(), "");
   ASSERT_TRUE(decryption_result.status().ok());
-  EXPECT_THAT(decryption_result.ValueOrDie(), Eq("secret"));
+  EXPECT_THAT(decryption_result.value(), Eq("secret"));
 
   decryption_result = DummyDeterministicAead("dummy").DecryptDeterministically(
-      encryption_result.ValueOrDie(), "wrong");
+      encryption_result.value(), "wrong");
   EXPECT_FALSE(decryption_result.status().ok());
 }
 
diff --git a/cc/daead/deterministic_aead_factory_test.cc b/cc/daead/deterministic_aead_factory_test.cc
index a2d81266f..78cc363f9 100644
--- a/cc/daead/deterministic_aead_factory_test.cc
+++ b/cc/daead/deterministic_aead_factory_test.cc
@@ -70,17 +70,17 @@ TEST_F(DeterministicAeadFactoryTest, testPrimitive) {
   // Prepare a Keyset.
   Keyset keyset;
   uint32_t key_id_1 = 1234543;
-  auto new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+  auto new_key = std::move(key_factory.NewKey(key_format).value());
   AddTinkKey(key_type, key_id_1, *new_key, KeyStatusType::ENABLED,
              KeyData::SYMMETRIC, &keyset);
 
   uint32_t key_id_2 = 726329;
-  new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+  new_key = std::move(key_factory.NewKey(key_format).value());
   AddRawKey(key_type, key_id_2, *new_key, KeyStatusType::ENABLED,
             KeyData::SYMMETRIC, &keyset);
 
   uint32_t key_id_3 = 7213743;
-  new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+  new_key = std::move(key_factory.NewKey(key_format).value());
   AddTinkKey(key_type, key_id_3, *new_key, KeyStatusType::ENABLED,
              KeyData::SYMMETRIC, &keyset);
 
@@ -93,7 +93,7 @@ TEST_F(DeterministicAeadFactoryTest, testPrimitive) {
   auto daead_result = DeterministicAeadFactory::GetPrimitive(
       *TestKeysetHandle::GetKeysetHandle(keyset));
   EXPECT_TRUE(daead_result.ok()) << daead_result.status();
-  auto daead = std::move(daead_result.ValueOrDie());
+  auto daead = std::move(daead_result.value());
 
   // Test the resulting DeterministicAead-instance.
   std::string plaintext = "some_plaintext";
@@ -101,14 +101,14 @@ TEST_F(DeterministicAeadFactoryTest, testPrimitive) {
 
   auto encrypt_result = daead->EncryptDeterministically(plaintext, aad);
   EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
-  std::string ciphertext = encrypt_result.ValueOrDie();
+  std::string ciphertext = encrypt_result.value();
   std::string prefix =
-      CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).ValueOrDie();
+      CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).value();
   EXPECT_PRED_FORMAT2(testing::IsSubstring, prefix, ciphertext);
 
   auto decrypt_result = daead->DecryptDeterministically(ciphertext, aad);
   EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
-  EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+  EXPECT_EQ(plaintext, decrypt_result.value());
 
   decrypt_result = daead->DecryptDeterministically("some bad ciphertext", aad);
   EXPECT_FALSE(decrypt_result.ok());
@@ -119,13 +119,13 @@ TEST_F(DeterministicAeadFactoryTest, testPrimitive) {
 
   // Create raw ciphertext with 2nd key, and decrypt
   // with DeterministicAead-instance.
-  auto raw_daead = std::move(
-      key_manager->GetPrimitive(keyset.key(1).key_data()).ValueOrDie());
+  auto raw_daead =
+      std::move(key_manager->GetPrimitive(keyset.key(1).key_data()).value());
   std::string raw_ciphertext =
-      raw_daead->EncryptDeterministically(plaintext, aad).ValueOrDie();
+      raw_daead->EncryptDeterministically(plaintext, aad).value();
   decrypt_result = daead->DecryptDeterministically(ciphertext, aad);
   EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
-  EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+  EXPECT_EQ(plaintext, decrypt_result.value());
 }
 
 }  // namespace
diff --git a/cc/daead/deterministic_aead_wrapper.cc b/cc/daead/deterministic_aead_wrapper.cc
index 685850d53..f72edaf2e 100644
--- a/cc/daead/deterministic_aead_wrapper.cc
+++ b/cc/daead/deterministic_aead_wrapper.cc
@@ -77,7 +77,7 @@ DeterministicAeadSetWrapper::EncryptDeterministically(
           plaintext, associated_data);
   if (!encrypt_result.ok()) return encrypt_result.status();
   const std::string& key_id = daead_set_->get_primary()->get_identifier();
-  return key_id + encrypt_result.ValueOrDie();
+  return key_id + encrypt_result.value();
 }
 
 util::StatusOr<std::string>
@@ -94,12 +94,12 @@ DeterministicAeadSetWrapper::DecryptDeterministically(
     if (primitives_result.ok()) {
       absl::string_view raw_ciphertext =
           ciphertext.substr(CryptoFormat::kNonRawPrefixSize);
-      for (auto& daead_entry : *(primitives_result.ValueOrDie())) {
+      for (auto& daead_entry : *(primitives_result.value())) {
         DeterministicAead& daead = daead_entry->get_primitive();
         auto decrypt_result =
             daead.DecryptDeterministically(raw_ciphertext, associated_data);
         if (decrypt_result.ok()) {
-          return std::move(decrypt_result.ValueOrDie());
+          return std::move(decrypt_result.value());
         } else {
           // LOG that a matching key didn't decrypt the ciphertext.
         }
@@ -110,12 +110,12 @@ DeterministicAeadSetWrapper::DecryptDeterministically(
   // No matching key succeeded with decryption, try all RAW keys.
   auto raw_primitives_result = daead_set_->get_raw_primitives();
   if (raw_primitives_result.ok()) {
-    for (auto& daead_entry : *(raw_primitives_result.ValueOrDie())) {
+    for (auto& daead_entry : *(raw_primitives_result.value())) {
       DeterministicAead& daead = daead_entry->get_primitive();
       auto decrypt_result =
           daead.DecryptDeterministically(ciphertext, associated_data);
       if (decrypt_result.ok()) {
-        return std::move(decrypt_result.ValueOrDie());
+        return std::move(decrypt_result.value());
       }
     }
   }
diff --git a/cc/daead/deterministic_aead_wrapper_test.cc b/cc/daead/deterministic_aead_wrapper_test.cc
index e268d6510..327ac13b3 100644
--- a/cc/daead/deterministic_aead_wrapper_test.cc
+++ b/cc/daead/deterministic_aead_wrapper_test.cc
@@ -108,24 +108,24 @@ TEST_F(DeterministicAeadSetWrapperTest, testBasic) {
         daead_set->AddPrimitive(std::move(daead), keyset_info.key_info(2));
     ASSERT_TRUE(entry_result.ok());
     // The last key is the primary.
-    ASSERT_THAT(daead_set->set_primary(entry_result.ValueOrDie()), IsOk());
+    ASSERT_THAT(daead_set->set_primary(entry_result.value()), IsOk());
 
     // Wrap daead_set and test the resulting DeterministicAead.
     auto daead_result =
         DeterministicAeadWrapper().Wrap(std::move(daead_set));
     EXPECT_TRUE(daead_result.ok()) << daead_result.status();
-    daead = std::move(daead_result.ValueOrDie());
+    daead = std::move(daead_result.value());
     std::string plaintext = "some_plaintext";
     std::string aad = "some_aad";
 
     auto encrypt_result = daead->EncryptDeterministically(plaintext, aad);
     EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
-    std::string ciphertext = encrypt_result.ValueOrDie();
+    std::string ciphertext = encrypt_result.value();
     EXPECT_PRED_FORMAT2(testing::IsSubstring, daead_name_2, ciphertext);
 
     auto decrypt_result = daead->DecryptDeterministically(ciphertext, aad);
     EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
-    EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+    EXPECT_EQ(plaintext, decrypt_result.value());
 
     decrypt_result =
         daead->DecryptDeterministically("some bad ciphertext", aad);