Remove base::BinaryValue

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api_chromeos_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 80 matching lines @@
     *user_public_key = "user public key";
     *user_private_key = "user private key";
   }
 
  private:
   ~TestableGetPermitAccessFunction() override {}
 
   DISALLOW_COPY_AND_ASSIGN(TestableGetPermitAccessFunction);
 };
 
-// Converts a string to a base::BinaryValue value whose buffer contains the
+// Converts a string to a base::Value value whose buffer contains the
 // string data without the trailing '\0'.
-std::unique_ptr<base::BinaryValue> StringToBinaryValue(
-    const std::string& value) {
-  return base::BinaryValue::CreateWithCopiedBuffer(value.data(),
-                                                   value.length());
+std::unique_ptr<base::Value> StringToBinaryValue(const std::string& value) {
+  return base::Value::CreateWithCopiedBuffer(value.data(), value.length());
 }
 
 // Copies |private_key_source| and |public_key_source| to |private_key_target|
 // and |public_key_target|. It is used as a callback for
 // |EasyUnlockClient::GenerateEcP256KeyPair| to save the values returned by the
 // method.
 void CopyKeyPair(std::string* private_key_target,
                  std::string* public_key_target,
                  const std::string& private_key_source,
                  const std::string& public_key_source) {
@@ skipping 40 matching lines @@
     if (!result_list) {
       LOG(ERROR) << "Function has no result list.";
       return "";
     }
 
     if (result_list->GetSize() != 1u) {
       LOG(ERROR) << "Invalid number of results.";
       return "";
     }
 
-    const base::BinaryValue* result_binary_value;
+    const base::Value* result_binary_value;
     if (!result_list->GetBinary(0, &result_binary_value) ||
         !result_binary_value) {
       LOG(ERROR) << "Result not a binary value.";
       return "";
     }
 
     return std::string(result_binary_value->GetBuffer(),
                        result_binary_value->GetSize());
   }
 
   chromeos::EasyUnlockClient* client_;
 };
 
 TEST_F(EasyUnlockPrivateApiTest, GenerateEcP256KeyPair) {
   scoped_refptr<EasyUnlockPrivateGenerateEcP256KeyPairFunction> function(
       new EasyUnlockPrivateGenerateEcP256KeyPairFunction());
   function->set_has_callback(true);
 
   ASSERT_TRUE(extension_function_test_utils::RunFunction(
       function.get(),
       "[]",
       browser(),
       extension_function_test_utils::NONE));
 
   const base::ListValue* result_list = function->GetResultList();
   ASSERT_TRUE(result_list);
   ASSERT_EQ(2u, result_list->GetSize());
 
-  const base::BinaryValue* public_key;
+  const base::Value* public_key;
   ASSERT_TRUE(result_list->GetBinary(0, &public_key));
   ASSERT_TRUE(public_key);
 
-  const base::BinaryValue* private_key;
+  const base::Value* private_key;
   ASSERT_TRUE(result_list->GetBinary(1, &private_key));
   ASSERT_TRUE(private_key);
 
   EXPECT_TRUE(chromeos::FakeEasyUnlockClient::IsEcP256KeyPair(
       std::string(private_key->GetBuffer(), private_key->GetSize()),
       std::string(public_key->GetBuffer(), public_key->GetSize())));
 }
 
 TEST_F(EasyUnlockPrivateApiTest, PerformECDHKeyAgreement) {
   scoped_refptr<EasyUnlockPrivatePerformECDHKeyAgreementFunction> function(
@@ skipping 442 matching lines @@
 
   scoped_refptr<TestableGetPermitAccessFunction> function(
       new TestableGetPermitAccessFunction());
   std::unique_ptr<base::Value> value(
       extensions::api_test_utils::RunFunctionAndReturnSingleResult(
           function.get(), "[]", profile()));
   EXPECT_FALSE(value);
 }
 
 }  // namespace