[Gin] Add Arguments::GetHolderCreationContext()

extensions/renderer/chrome_setting.cc

 // Copyright 2017 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/chrome_setting.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/renderer/api_event_handler.h"
@@ skipping 86 matching lines @@
       .SetProperty("onChange", &ChromeSetting::GetOnChangeEvent);
 }
 
 void ChromeSetting::Get(gin::Arguments* arguments) {
   HandleFunction("get", arguments);
 }
 
 void ChromeSetting::Set(gin::Arguments* arguments) {
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
-
-  v8::Local<v8::Object> holder;
-  CHECK(arguments->GetHolder(&holder));
-  v8::Local<v8::Context> context = holder->CreationContext();
+  v8::Local<v8::Context> context = arguments->GetHolderCreationContext();
 
   v8::Local<v8::Value> value = arguments->PeekNext();
   // The set schema included in the Schema object is generic, since it varies
   // per-setting. However, this is only ever for a single setting, so we can
   // enforce the types more thoroughly.
   std::string error;
   if (!value.IsEmpty() && !argument_spec_.ParseArgument(
                               context, value, *type_refs_, nullptr, &error)) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
   HandleFunction("set", arguments);
 }
 
 void ChromeSetting::Clear(gin::Arguments* arguments) {
   HandleFunction("clear", arguments);
 }
 
 v8::Local<v8::Value> ChromeSetting::GetOnChangeEvent(
     gin::Arguments* arguments) {
   v8::Isolate* isolate = arguments->isolate();
-  v8::Local<v8::Object> holder;
-  CHECK(arguments->GetHolder(&holder));
-  v8::Local<v8::Context> context = holder->CreationContext();
+  v8::Local<v8::Context> context = arguments->GetHolderCreationContext();
   v8::Local<v8::Object> wrapper = GetWrapper(isolate);
   v8::Local<v8::Private> key = v8::Private::ForApi(
       isolate, gin::StringToSymbol(isolate, "onChangeEvent"));
   v8::Local<v8::Value> event;
   if (!wrapper->GetPrivate(context, key).ToLocal(&event)) {
     NOTREACHED();
     return v8::Local<v8::Value>();
   }
 
   DCHECK(!event.IsEmpty());
   if (event->IsUndefined()) {
     bool supports_filters = false;
     event = event_handler_->CreateEventInstance(
         base::StringPrintf("types.ChromeSetting.%s.onChange",
                            pref_name_.c_str()),
         supports_filters, context);
     v8::Maybe<bool> set_result = wrapper->SetPrivate(context, key, event);
     if (!set_result.IsJust() || !set_result.FromJust()) {
       NOTREACHED();
       return v8::Local<v8::Value>();
     }
   }
   return event;
 }
 
 void ChromeSetting::HandleFunction(const std::string& method_name,
                                    gin::Arguments* arguments) {
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Local<v8::Object> holder;
-  CHECK(arguments->GetHolder(&holder));
-  v8::Local<v8::Context> context = holder->CreationContext();
+  v8::Local<v8::Context> context = arguments->GetHolderCreationContext();
 
   std::vector<v8::Local<v8::Value>> argument_list;
   if (arguments->Length() > 0) {
     // Just copying handles should never fail.
     CHECK(arguments->GetRemaining(&argument_list));
   }
 
   std::string full_name = "types.ChromeSetting." + method_name;
   std::unique_ptr<base::ListValue> converted_arguments;
   v8::Local<v8::Function> callback;
   std::string error;
   if (!type_refs_->GetTypeMethodSignature(full_name)->ParseArgumentsToJSON(
           context, argument_list, *type_refs_, &converted_arguments, &callback,
           &error)) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   converted_arguments->Insert(0u, base::MakeUnique<base::Value>(pref_name_));
   request_handler_->StartRequest(context, full_name,
                                  std::move(converted_arguments), callback,
                                  v8::Local<v8::Function>());
 }
 
 }  // namespace extensions