[Extensions Bindings] Add enum support

extensions/renderer/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/api_binding.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/renderer/api_binding_hooks.h"
 #include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_signature.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "gin/arguments.h"
 #include "gin/per_context_data.h"
 
 namespace extensions {
 
 namespace {
 
+// Returns the name of the enum value for use in JavaScript; JS enum entries use
+// SCREAMING_STYLE.
+std::string GetJSEnumEntryName(const std::string& original) {
+  std::string result;
+  DCHECK(!original.empty());
+  // If the original starts with a digit, prefix it with an underscore.
+  if (base::IsAsciiDigit(original[0]))
+    result.push_back('_');
+  // Given 'myEnum-Foo':
+  for (size_t i = 0; i < original.size(); ++i) {
+    // Add an underscore between camelcased items:
+    // 'myEnum-Foo' -> 'mY_Enum-Foo'
+    if (i > 0 && base::IsAsciiLower(original[i - 1]) &&
+        base::IsAsciiUpper(original[i])) {
+      result.push_back('_');
+      result.push_back(original[i]);
+    } else if (original[i] == '-') {  // 'mY_Enum-Foo' -> 'mY_Enum_Foo'
+      result.push_back('_');
+    } else {  // 'mY_Enum_Foo' -> 'MY_ENUM_FOO'
+      result.push_back(base::ToUpperASCII(original[i]));
+    }
+  }
+  return result;
+}
+
 const char kExtensionAPIPerContextKey[] = "extension_api_binding";
 
 struct APIPerContextData : public base::SupportsUserData::Data {
   std::vector<std::unique_ptr<APIBinding::HandlerCallback>> context_callbacks;
 };
 
 void CallbackHelper(const v8::FunctionCallbackInfo<v8::Value>& info) {
   gin::Arguments args(info);
 
   // If the current context (the in which this function was created) has been
@@ skipping 45 matching lines @@
       const base::DictionaryValue* func_dict = nullptr;
       CHECK(func->GetAsDictionary(&func_dict));
       std::string name;
       CHECK(func_dict->GetString("name", &name));
 
       const base::ListValue* params = nullptr;
       CHECK(func_dict->GetList("parameters", &params));
       signatures_[name] = base::MakeUnique<APISignature>(*params);
     }
   }
+
   if (type_definitions) {
     for (const auto& type : *type_definitions) {
       const base::DictionaryValue* type_dict = nullptr;
       CHECK(type->GetAsDictionary(&type_dict));
       std::string id;
       CHECK(type_dict->GetString("id", &id));
       DCHECK(type_refs->find(id) == type_refs->end());
       // TODO(devlin): refs are sometimes preceeded by the API namespace; we
       // might need to take that into account.
-      (*type_refs)[id] = base::MakeUnique<ArgumentSpec>(*type_dict);
+      auto argument_spec = base::MakeUnique<ArgumentSpec>(*type_dict);
+      const std::set<std::string>& enum_values = argument_spec->enum_values();
+      if (!enum_values.empty()) {
+        // Type names may be prefixed by the api name. If so, remove the prefix.
+        base::Optional<std::string> stripped_id;
+        if (base::StartsWith(id, api_name_, base::CompareCase::SENSITIVE))
+          stripped_id = id.substr(api_name_.size() + 1);  // +1 for trailing '.'
+        std::vector<EnumEntry>& entries =
+            enums_[stripped_id ? *stripped_id : id];
+        entries.reserve(enum_values.size());
+        for (const auto& enum_value : enum_values) {
+          entries.push_back(
+              std::make_pair(enum_value, GetJSEnumEntryName(enum_value)));
+        }
+      }
+      (*type_refs)[id] = std::move(argument_spec);
     }
   }
+
   if (event_definitions) {
     event_names_.reserve(event_definitions->GetSize());
     for (const auto& event : *event_definitions) {
       const base::DictionaryValue* event_dict = nullptr;
       CHECK(event->GetAsDictionary(&event_dict));
       std::string name;
       CHECK(event_dict->GetString("name", &name));
       event_names_.push_back(std::move(name));
     }
   }
@@ skipping 14 matching lines @@
   gin::PerContextData* per_context_data = gin::PerContextData::From(context);
   DCHECK(per_context_data);
   APIPerContextData* data = static_cast<APIPerContextData*>(
       per_context_data->GetUserData(kExtensionAPIPerContextKey));
   if (!data) {
     auto api_data = base::MakeUnique<APIPerContextData>();
     data = api_data.get();
     per_context_data->SetUserData(kExtensionAPIPerContextKey,
                                   api_data.release());
   }
+
   for (const auto& sig : signatures_) {
     std::string full_method_name =
         base::StringPrintf("%s.%s", api_name_.c_str(), sig.first.c_str());
 
     if (!is_available.Run(full_method_name))
       continue;
 
     auto handler_callback = base::MakeUnique<HandlerCallback>(
         base::Bind(&APIBinding::HandleCall, weak_factory_.GetWeakPtr(),
                    full_method_name, sig.second.get()));
@@ skipping 15 matching lines @@
         base::StringPrintf("%s.%s", api_name_.c_str(), event_name.c_str());
     v8::Local<v8::Object> event =
         event_handler->CreateEventInstance(full_event_name, context);
     DCHECK(!event.IsEmpty());
     v8::Maybe<bool> success = object->CreateDataProperty(
         context, gin::StringToSymbol(isolate, event_name), event);
     DCHECK(success.IsJust());
     DCHECK(success.FromJust());
   }
 
+  for (const auto& entry : enums_) {
+    // TODO(devlin): Store these on an ObjectTemplate.
+    v8::Local<v8::Object> enum_object = v8::Object::New(isolate);
+    for (const auto& enum_entry : entry.second) {
+      v8::Maybe<bool> success = enum_object->CreateDataProperty(
+          context, gin::StringToSymbol(isolate, enum_entry.second),
+          gin::StringToSymbol(isolate, enum_entry.first));
+      DCHECK(success.IsJust());
+      DCHECK(success.FromJust());
+    }
+    v8::Maybe<bool> success = object->CreateDataProperty(
+        context, gin::StringToSymbol(isolate, entry.first), enum_object);
+    DCHECK(success.IsJust());
+    DCHECK(success.FromJust());
+  }
+
   binding_hooks_->InitializeInContext(context, api_name_);
 
   return object;
 }
 
 v8::Local<v8::Object> APIBinding::GetJSHookInterface(
     v8::Local<v8::Context> context) {
   return binding_hooks_->GetJSHookInterface(api_name_, context);
 }
 
@@ skipping 61 matching lines @@
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   DCHECK(converted_arguments);
   method_callback_.Run(name, std::move(converted_arguments), isolate, context,
                        callback);
 }
 
 }  // namespace extensions