Remove base::Value::Get{Buffer,Size}

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 151 matching lines @@
       return "";
     }
 
     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());
+    return std::string(result_binary_value->GetBlob().data(),
+                       result_binary_value->GetBlob().size());
   }
 
   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::Value* public_key;
   ASSERT_TRUE(result_list->GetBinary(0, &public_key));
   ASSERT_TRUE(public_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())));
+      std::string(private_key->GetBlob().data(), private_key->GetBlob().size()),
+      std::string(public_key->GetBlob().data(), public_key->GetBlob().size())));
 }
 
 TEST_F(EasyUnlockPrivateApiTest, PerformECDHKeyAgreement) {
   scoped_refptr<EasyUnlockPrivatePerformECDHKeyAgreementFunction> function(
       new EasyUnlockPrivatePerformECDHKeyAgreementFunction());
   function->set_has_callback(true);
 
   std::string private_key_1;
   std::string public_key_1_unused;
   client_->GenerateEcP256KeyPair(
@@ skipping 436 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