[Extensions Bindings] Check availability of custom API properties

extensions/renderer/bindings/api_binding.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/api_binding.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 #include "extensions/renderer/bindings/declarative_event.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/per_context_data.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 namespace extensions {
 
 namespace {
 
+std::string GetPlatformString() {
+#if defined(OS_CHROMEOS)
+  return "chromeos";
+#elif defined(OS_LINUX)
+  return "linux";
+#elif defined(OS_MACOSX)
+  return "mac";
+#elif defined(OS_WIN)
+  return "win";
+#else
+  NOTREACHED();
+  return std::string();
+#endif
+}
+
 // Returns the name of the enum value for use in JavaScript; JS enum entries use
 // SCREAMING_STYLE.
 std::string GetJSEnumEntryName(const std::string& original) {
   // The webstorePrivate API has an empty enum value for a result.
   // TODO(devlin): Work with the webstore team to see if we can move them off
   // this - they also already have a "success" result that they can use.
   // See crbug.com/709120.
   if (original.empty())
     return original;
 
@@ skipping 378 matching lines @@
     const base::DictionaryValue* dict = nullptr;
     CHECK(iter.value().GetAsDictionary(&dict));
     bool optional = false;
     if (dict->GetBoolean("optional", &optional)) {
       // TODO(devlin): What does optional even mean here? It's only used, it
       // seems, for lastError and inIncognitoContext, which are both handled
       // with custom bindings. Investigate, and remove.
       continue;
     }
 
+    const base::ListValue* platforms = nullptr;
+    // TODO(devlin): This isn't great. It's bad to have availability primarily
+    // defined in the features files, and then partially defined within the
+    // API specification itself. Additionally, they aren't equivalent
+    // definitions. But given the rarity of property restrictions, and the fact
+    // that they are all limited by platform, it makes more sense to isolate
+    // this check here. If this becomes more common, we should really find a
+    // way of moving these checks to the features files.
+    if (dict->GetList("platforms", &platforms)) {
+      std::string this_platform = GetPlatformString();
+      auto is_this_platform = [&this_platform](const base::Value& platform) {
+        return platform.is_string() && platform.GetString() == this_platform;
+      };
+      if (std::none_of(platforms->begin(), platforms->end(), is_this_platform))
+        continue;
+    }
+
     v8::Local<v8::String> v8_key = gin::StringToSymbol(isolate, iter.key());
     std::string ref;
     if (dict->GetString("$ref", &ref)) {
       const base::ListValue* property_values = nullptr;
       CHECK(dict->GetList("value", &property_values));
       auto property_data = base::MakeUnique<CustomPropertyData>(
           ref, iter.key(), property_values, create_custom_type_);
       object_template->SetLazyDataProperty(
           v8_key, &APIBinding::GetCustomPropertyObject,
           v8::External::New(isolate, property_data.get()));
@@ skipping 181 matching lines @@
     arguments->ThrowTypeError(api_errors::InvocationError(
         name, signature->GetExpectedSignature(), error));
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback, thread);
 }
 
 }  // namespace extensions