[Extensions Bindings] Support ArrayBufferView in idl files

extensions/renderer/bindings/argument_spec.cc

 // Copyright 2016 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 "extensions/renderer/bindings/argument_spec.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 148 matching lines @@
       }
     }
     const base::DictionaryValue* additional_properties_value = nullptr;
     if (dict->GetDictionary("additionalProperties",
                             &additional_properties_value)) {
       additional_properties_ =
           base::MakeUnique<ArgumentSpec>(*additional_properties_value);
       // Additional properties are always optional.
       additional_properties_->optional_ = true;
     }
-    std::string instance_of;
-    if (dict->GetString("isInstanceOf", &instance_of)) {
-      instance_of_ = instance_of;
-    }
   } else if (type_ == ArgumentType::LIST) {
     const base::DictionaryValue* item_value = nullptr;
     CHECK(dict->GetDictionary("items", &item_value));
     list_element_type_ = base::MakeUnique<ArgumentSpec>(*item_value);
   } else if (type_ == ArgumentType::STRING) {
     // Technically, there's no reason enums couldn't be other objects (e.g.
     // numbers), but right now they seem to be exclusively strings. We could
     // always update this if need be.
     const base::ListValue* enums = nullptr;
     if (dict->GetList("enum", &enums)) {
@@ skipping 11 matching lines @@
         enum_values_.insert(std::move(enum_value));
       }
     }
   }
 
   // Check if we should preserve null in objects. Right now, this is only used
   // on arguments of type object and any (in fact, it's only used in the storage
   // API), but it could potentially make sense for lists or functions as well.
   if (type_ == ArgumentType::OBJECT || type_ == ArgumentType::ANY)
     dict->GetBoolean("preserveNull", &preserve_null_);
+
+  if (type_ == ArgumentType::OBJECT || type_ == ArgumentType::BINARY) {
+    std::string instance_of;
+    if (dict->GetString("isInstanceOf", &instance_of))
+      instance_of_ = instance_of;
+  }
 }
 
 ArgumentSpec::~ArgumentSpec() {}
 
 bool ArgumentSpec::ParseArgument(v8::Local<v8::Context> context,
                                  v8::Local<v8::Value> value,
                                  const APITypeReferenceMap& refs,
                                  std::unique_ptr<base::Value>* out_value,
                                  std::string* error) const {
   if (type_ == ArgumentType::FUNCTION) {
@@ skipping 420 matching lines @@
   return true;
 }
 
 std::string ArgumentSpec::GetInvalidTypeError(
     v8::Local<v8::Value> value) const {
   return api_errors::InvalidType(GetTypeName().c_str(),
                                  GetV8ValueTypeString(value));
 }
 
 }  // namespace extensions