[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";

[jbroman, 2017/06/29 15:24:21]

I assume you'll look into what's up with protectedContentEnabled referring to
"cros" and "cros touch", which aren't used here or in binding.js?

[Devlin, 2017/06/29 21:00:51]

Yep!  This just puts it more inline with the end result of the current bindings
and uses the same enums as the features files.

+#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 platform_string = GetPlatformString();
+      bool allowed = false;
+      for (const auto& platform : *platforms) {

[jbroman, 2017/06/29 15:24:20]

super-nit: your choice, but I mildly prefer <algorithm> style here:

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;

[Devlin, 2017/06/29 21:00:51]

Oh, forgot about none_of.  I had a version that used find_if(...) != end(), but
that was clunkier than the for loop.  This is nice, though.

Done.

+        if (platform.is_string() && platform.GetString() == platform_string) {
+          allowed = true;
+          break;
+        }
+      }
+
+      if (!allowed)
+        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