Remove deprecated ListValue::GetBinary().

BUG=646113

Change-Id: I0f4591d38064ca0e8f27a514fbcb633ab2c52348
Reviewed-on: https://chromium-review.googlesource.com/764955
Commit-Queue: Lei Zhang <thestig@chromium.org>
Reviewed-by: Brett Wilson <brettw@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#517158}

base/values.cc

@@ -1221,23 +1221,6 @@ bool ListValue::GetString(size_t index, string16* out_value) const {
   return value->GetAsString(out_value);
 }
 
-bool ListValue::GetBinary(size_t index, const Value** out_value) const {
-  const Value* value;
-  bool result = Get(index, &value);
-  if (!result || !value->IsType(Type::BINARY))
-    return false;
-
-  if (out_value)
-    *out_value = value;
-
-  return true;
-}
-
-bool ListValue::GetBinary(size_t index, Value** out_value) {
-  return static_cast<const ListValue&>(*this).GetBinary(
-      index, const_cast<const Value**>(out_value));
-}
-
 bool ListValue::GetDictionary(size_t index,
                               const DictionaryValue** out_value) const {
   const Value* value;

base/values.h

@@ -647,9 +647,6 @@ class BASE_EXPORT ListValue : public Value {
   // DEPRECATED, use GetList()::operator[]::GetString() instead.
   bool GetString(size_t index, std::string* out_value) const;
   bool GetString(size_t index, string16* out_value) const;
-  // DEPRECATED, use GetList()::operator[]::GetBlob() instead.
-  bool GetBinary(size_t index, const Value** out_value) const;
-  bool GetBinary(size_t index, Value** out_value);
 
   bool GetDictionary(size_t index, const DictionaryValue** out_value) const;
   bool GetDictionary(size_t index, DictionaryValue** out_value);

base/values_unittest.cc

@@ -1876,15 +1876,6 @@ TEST(ValuesTest, GetWithNullOutValue) {
   EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(nullptr)));
   EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(nullptr)));
 
-  EXPECT_FALSE(main_list.GetBinary(0, nullptr));
-  EXPECT_FALSE(main_list.GetBinary(1, nullptr));
-  EXPECT_FALSE(main_list.GetBinary(2, nullptr));
-  EXPECT_FALSE(main_list.GetBinary(3, nullptr));
-  EXPECT_TRUE(main_list.GetBinary(4, nullptr));
-  EXPECT_FALSE(main_list.GetBinary(5, nullptr));
-  EXPECT_FALSE(main_list.GetBinary(6, nullptr));
-  EXPECT_FALSE(main_list.GetBinary(7, nullptr));
-
   EXPECT_FALSE(main_list.GetDictionary(0, nullptr));
   EXPECT_FALSE(main_list.GetDictionary(1, nullptr));
   EXPECT_FALSE(main_list.GetDictionary(2, nullptr));

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

@@ -154,23 +154,22 @@ class EasyUnlockPrivateApiTest : public extensions::ExtensionApiUnittest {
     const base::ListValue* result_list = function->GetResultList();
     if (!result_list) {
       LOG(ERROR) << "Function has no result list.";
-      return "";
+      return std::string();
     }
 
     if (result_list->GetSize() != 1u) {
       LOG(ERROR) << "Invalid number of results.";
-      return "";
+      return std::string();
     }
 
-    const base::Value* result_binary_value;
-    if (!result_list->GetBinary(0, &result_binary_value) ||
-        !result_binary_value) {
+    const auto& result_binary_value = result_list->GetList()[0];
+    if (!result_binary_value.is_blob()) {
       LOG(ERROR) << "Result not a binary value.";
-      return "";
+      return std::string();
     }
 
-    return std::string(result_binary_value->GetBlob().data(),
-                       result_binary_value->GetBlob().size());
+    return std::string(result_binary_value.GetBlob().data(),
+                       result_binary_value.GetBlob().size());
   }
 
   chromeos::EasyUnlockClient* client_;
@@ -191,17 +190,14 @@ TEST_F(EasyUnlockPrivateApiTest, GenerateEcP256KeyPair) {
   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);
+  const base::Value& public_key = result_list->GetList()[0];
+  const base::Value& private_key = result_list->GetList()[1];
+  ASSERT_TRUE(public_key.is_blob());
+  ASSERT_TRUE(private_key.is_blob());
 
   EXPECT_TRUE(chromeos::FakeEasyUnlockClient::IsEcP256KeyPair(
-      std::string(private_key->GetBlob().data(), private_key->GetBlob().size()),
-      std::string(public_key->GetBlob().data(), public_key->GetBlob().size())));
+      std::string(private_key.GetBlob().data(), private_key.GetBlob().size()),
+      std::string(public_key.GetBlob().data(), public_key.GetBlob().size())));
 }
 
 TEST_F(EasyUnlockPrivateApiTest, PerformECDHKeyAgreement) {

chrome/browser/extensions/api/idltest/idltest_api.cc

@@ -7,38 +7,40 @@
 #include <stddef.h>
 
 #include <memory>
+#include <utility>
 
 #include "base/values.h"
 
-using base::Value;
-
 namespace {
 
-std::unique_ptr<base::ListValue> CopyBinaryValueToIntegerList(
-    const Value* input) {
-  std::unique_ptr<base::ListValue> output(new base::ListValue());
-  for (char c : input->GetBlob()) {
-    output->AppendInteger(c);
-  }
-  return output;
+std::unique_ptr<base::Value> CopyBinaryValueToIntegerList(
+    const base::Value::BlobStorage& input) {
+  base::Value output(base::Value::Type::LIST);
+  auto& list = output.GetList();
+  list.reserve(input.size());
+  for (int c : input)
+    list.emplace_back(c);
+  return base::Value::ToUniquePtrValue(std::move(output));
 }
 
 }  // namespace
 
 ExtensionFunction::ResponseAction IdltestSendArrayBufferFunction::Run() {
-  Value* input = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_ != NULL && args_->GetBinary(0, &input));
-  return RespondNow(OneArgument(CopyBinaryValueToIntegerList(input)));
+  EXTENSION_FUNCTION_VALIDATE(args_ && !args_->GetList().empty());
+  const auto& value = args_->GetList()[0];
+  EXTENSION_FUNCTION_VALIDATE(value.is_blob());
+  return RespondNow(OneArgument(CopyBinaryValueToIntegerList(value.GetBlob())));
 }
 
 ExtensionFunction::ResponseAction IdltestSendArrayBufferViewFunction::Run() {
-  Value* input = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_ != NULL && args_->GetBinary(0, &input));
-  return RespondNow(OneArgument(CopyBinaryValueToIntegerList(input)));
+  EXTENSION_FUNCTION_VALIDATE(args_ && !args_->GetList().empty());
+  const auto& value = args_->GetList()[0];
+  EXTENSION_FUNCTION_VALIDATE(value.is_blob());
+  return RespondNow(OneArgument(CopyBinaryValueToIntegerList(value.GetBlob())));
 }
 
 ExtensionFunction::ResponseAction IdltestGetArrayBufferFunction::Run() {
-  std::string hello = "hello world";
+  static constexpr char kHello[] = "hello world";
   return RespondNow(
-      OneArgument(Value::CreateWithCopiedBuffer(hello.c_str(), hello.size())));
+      OneArgument(base::Value::CreateWithCopiedBuffer(kHello, strlen(kHello))));
 }

extensions/browser/api/declarative/declarative_api.cc

@@ -6,6 +6,10 @@
 
 #include <stddef.h>
 
+#include <memory>
+#include <utility>
+#include <vector>
+
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -87,36 +91,28 @@ void RecordUMAHelper(DeclarativeAPIFunctionType type) {
                             kDeclarativeApiFunctionCallTypeMax);
 }
 
-void ConvertBinaryDictionaryValuesToBase64(base::DictionaryValue* dict);
+void ConvertBinaryDictionaryValuesToBase64(base::Value* dict);
 
 // Encodes |binary| as base64 and returns a new StringValue populated with the
 // encoded string.
-std::unique_ptr<base::Value> ConvertBinaryToBase64(base::Value* binary) {
-  std::string binary_data(binary->GetBlob().data(), binary->GetBlob().size());
+base::Value ConvertBinaryToBase64(const base::Value& binary) {
+  std::string binary_data(binary.GetBlob().data(), binary.GetBlob().size());
   std::string data64;
   base::Base64Encode(binary_data, &data64);
-  return std::unique_ptr<base::Value>(new base::Value(data64));
+  return base::Value(std::move(data64));
 }
 
 // Parses through |args| replacing any BinaryValues with base64 encoded
 // StringValues. Recurses over any nested ListValues, and calls
 // ConvertBinaryDictionaryValuesToBase64 for any nested DictionaryValues.
-void ConvertBinaryListElementsToBase64(base::ListValue* args) {
-  size_t index = 0;
-  for (base::ListValue::iterator iter = args->begin(); iter != args->end();
-       ++iter, ++index) {
-    if (iter->IsType(base::Value::Type::BINARY)) {
-      base::Value* binary = NULL;
-      if (args->GetBinary(index, &binary))
-        args->Set(index, ConvertBinaryToBase64(binary));
-    } else if (iter->IsType(base::Value::Type::LIST)) {
-      base::ListValue* list;
-      iter->GetAsList(&list);
-      ConvertBinaryListElementsToBase64(list);
-    } else if (iter->IsType(base::Value::Type::DICTIONARY)) {
-      base::DictionaryValue* dict;
-      iter->GetAsDictionary(&dict);
-      ConvertBinaryDictionaryValuesToBase64(dict);
+void ConvertBinaryListElementsToBase64(base::Value* args) {
+  for (auto& value : args->GetList()) {
+    if (value.is_blob()) {
+      value = ConvertBinaryToBase64(value);
+    } else if (value.is_list()) {
+      ConvertBinaryListElementsToBase64(&value);
+    } else if (value.is_dict()) {
+      ConvertBinaryDictionaryValuesToBase64(&value);
     }
   }
 }
@@ -124,31 +120,22 @@ void ConvertBinaryListElementsToBase64(base::ListValue* args) {
 // Parses through |dict| replacing any BinaryValues with base64 encoded
 // StringValues. Recurses over any nested DictionaryValues, and calls
 // ConvertBinaryListElementsToBase64 for any nested ListValues.
-void ConvertBinaryDictionaryValuesToBase64(base::DictionaryValue* dict) {
-  for (base::DictionaryValue::Iterator iter(*dict); !iter.IsAtEnd();
-       iter.Advance()) {
-    if (iter.value().IsType(base::Value::Type::BINARY)) {
-      base::Value* binary = NULL;
-      if (dict->GetBinary(iter.key(), &binary))
-        dict->Set(iter.key(), ConvertBinaryToBase64(binary));
-    } else if (iter.value().IsType(base::Value::Type::LIST)) {
-      const base::ListValue* list;
-      iter.value().GetAsList(&list);
-      ConvertBinaryListElementsToBase64(const_cast<base::ListValue*>(list));
-    } else if (iter.value().IsType(base::Value::Type::DICTIONARY)) {
-      const base::DictionaryValue* dict;
-      iter.value().GetAsDictionary(&dict);
-      ConvertBinaryDictionaryValuesToBase64(
-          const_cast<base::DictionaryValue*>(dict));
+void ConvertBinaryDictionaryValuesToBase64(base::Value* dict) {
+  for (auto it : dict->DictItems()) {
+    auto& value = it.second;
+    if (value.is_blob()) {
+      value = ConvertBinaryToBase64(value);
+    } else if (value.is_list()) {
+      ConvertBinaryListElementsToBase64(&value);
+    } else if (value.is_dict()) {
+      ConvertBinaryDictionaryValuesToBase64(&value);
     }
   }
 }
 
 }  // namespace
 
-RulesFunction::RulesFunction()
-    : rules_registry_(NULL) {
-}
+RulesFunction::RulesFunction() {}
 
 RulesFunction::~RulesFunction() {}
 
@@ -160,10 +147,10 @@ bool RulesFunction::HasPermission() {
 
   // <webview> embedders use the declarativeWebRequest API via
   // <webview>.onRequest.
-  if (web_view_instance_id != 0 &&
-      extension_->permissions_data()->HasAPIPermission(
-          extensions::APIPermission::kWebView))
+  if (web_view_instance_id && extension_->permissions_data()->HasAPIPermission(
+                                  APIPermission::kWebView)) {
     return true;
+  }
   return ExtensionFunction::HasPermission();
 }
 

extensions/browser/api/declarative/declarative_api.h

@@ -5,7 +5,8 @@
 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_DECLARATIVE_API_H_
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_DECLARATIVE_API_H_
 
-#include "base/compiler_specific.h"
+#include <string>
+
 #include "base/memory/ref_counted.h"
 #include "extensions/browser/api/declarative/rules_registry.h"
 #include "extensions/browser/extension_function.h"

extensions/browser/api/socket/socket_api.cc

@@ -534,12 +534,17 @@ SocketWriteFunction::SocketWriteFunction()
 SocketWriteFunction::~SocketWriteFunction() {}
 
 bool SocketWriteFunction::Prepare() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  base::Value* data = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
-
-  io_buffer_size_ = data->GetBlob().size();
-  io_buffer_ = new net::WrappedIOBuffer(data->GetBlob().data());
+  const auto& list = args_->GetList();
+  EXTENSION_FUNCTION_VALIDATE(list.size() >= 2);
+  const auto& socket_id_value = list[0];
+  const auto& data_value = list[1];
+  EXTENSION_FUNCTION_VALIDATE(socket_id_value.is_int());
+  EXTENSION_FUNCTION_VALIDATE(data_value.is_blob());
+
+  socket_id_ = socket_id_value.GetInt();
+  io_buffer_size_ = data_value.GetBlob().size();
+  io_buffer_ =
+      base::MakeRefCounted<net::WrappedIOBuffer>(data_value.GetBlob().data());
   return true;
 }
 
@@ -615,20 +620,29 @@ SocketSendToFunction::SocketSendToFunction()
 SocketSendToFunction::~SocketSendToFunction() {}
 
 bool SocketSendToFunction::Prepare() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  base::Value* data = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
-  int port;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port));
+  const auto& list = args_->GetList();
+  EXTENSION_FUNCTION_VALIDATE(list.size() >= 4);
+  const auto& socket_id_value = list[0];
+  const auto& data_value = list[1];
+  const auto& hostname_value = list[2];
+  const auto& port_value = list[3];
+  EXTENSION_FUNCTION_VALIDATE(socket_id_value.is_int());
+  EXTENSION_FUNCTION_VALIDATE(data_value.is_blob());
+  EXTENSION_FUNCTION_VALIDATE(hostname_value.is_string());
+  EXTENSION_FUNCTION_VALIDATE(port_value.is_int());
+
+  int port = port_value.GetInt();
   if (!IsPortValid(port)) {
     error_ = kPortInvalidError;
     return false;
   }
   port_ = static_cast<uint16_t>(port);
+  socket_id_ = socket_id_value.GetInt();
+  hostname_ = hostname_value.GetString();
 
-  io_buffer_size_ = data->GetBlob().size();
-  io_buffer_ = new net::WrappedIOBuffer(data->GetBlob().data());
+  io_buffer_size_ = data_value.GetBlob().size();
+  io_buffer_ =
+      base::MakeRefCounted<net::WrappedIOBuffer>(data_value.GetBlob().data());
   return true;
 }