extensions/renderer: Use v8::Local instead of v8::Handle.

extensions/renderer/dispatcher.cc

 // Copyright 2014 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/dispatcher.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 106 matching lines @@
 static const int64 kMaxExtensionIdleHandlerDelayMs = 5 * 60 * 1000;
 static const char kEventDispatchFunction[] = "dispatchEvent";
 static const char kOnSuspendEvent[] = "runtime.onSuspend";
 static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
 
 // Returns the global value for "chrome" from |context|. If one doesn't exist
 // creates a new object for it.
 //
 // Note that this isn't necessarily an object, since webpages can write, for
 // example, "window.chrome = true".
-v8::Handle<v8::Value> GetOrCreateChrome(ScriptContext* context) {
-  v8::Handle<v8::String> chrome_string(
+v8::Local<v8::Value> GetOrCreateChrome(ScriptContext* context) {
+  v8::Local<v8::String> chrome_string(
       v8::String::NewFromUtf8(context->isolate(), "chrome"));
-  v8::Handle<v8::Object> global(context->v8_context()->Global());
-  v8::Handle<v8::Value> chrome(global->Get(chrome_string));
+  v8::Local<v8::Object> global(context->v8_context()->Global());
+  v8::Local<v8::Value> chrome(global->Get(chrome_string));
   if (chrome->IsUndefined()) {
     chrome = v8::Object::New(context->isolate());
     global->Set(chrome_string, chrome);
   }
   return chrome;
 }
 
 // Returns |value| cast to an object if possible, else an empty handle.
-v8::Handle<v8::Object> AsObjectOrEmpty(v8::Handle<v8::Value> value) {
-  return value->IsObject() ? value.As<v8::Object>() : v8::Handle<v8::Object>();
+v8::Local<v8::Object> AsObjectOrEmpty(v8::Local<v8::Value> value) {
+  return value->IsObject() ? value.As<v8::Object>() : v8::Local<v8::Object>();
 }
 
 // Calls a method |method_name| in a module |module_name| belonging to the
 // module system from |context|. Intended as a callback target from
 // ScriptContextSet::ForEach.
 void CallModuleMethod(const std::string& module_name,
                       const std::string& method_name,
                       const base::ListValue* args,
                       ScriptContext* context) {
   v8::HandleScope handle_scope(context->isolate());
   v8::Context::Scope context_scope(context->v8_context());
 
   scoped_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
 
-  std::vector<v8::Handle<v8::Value> > arguments;
+  std::vector<v8::Local<v8::Value>> arguments;
   for (base::ListValue::const_iterator it = args->begin(); it != args->end();
        ++it) {
     arguments.push_back(converter->ToV8Value(*it, context->v8_context()));
   }
 
   context->module_system()->CallModuleMethod(
       module_name, method_name, &arguments);
 }
 
 // This handles the "chrome." root API object in script contexts.
@@ skipping 54 matching lines @@
 bool Dispatcher::IsExtensionActive(const std::string& extension_id) const {
   bool is_active =
       active_extension_ids_.find(extension_id) != active_extension_ids_.end();
   if (is_active)
     CHECK(extensions_.Contains(extension_id));
   return is_active;
 }
 
 void Dispatcher::DidCreateScriptContext(
     blink::WebLocalFrame* frame,
-    const v8::Handle<v8::Context>& v8_context,
+    const v8::Local<v8::Context>& v8_context,
     int extension_group,
     int world_id) {
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
   ScriptContext* context = script_context_set_->Register(
       frame, v8_context, extension_group, world_id);
 
   // Initialize origin permissions for content scripts, which can't be
   // initialized in |OnActivateExtension|.
   if (context->context_type() == Feature::CONTENT_SCRIPT_CONTEXT)
     InitOriginPermissions(context->extension());
 
   {
     scoped_ptr<ModuleSystem> module_system(
         new ModuleSystem(context, &source_map_));
     context->set_module_system(module_system.Pass());
   }
   ModuleSystem* module_system = context->module_system();
 
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
 
   RegisterNativeHandlers(module_system, context);
 
   // chrome.Event is part of the public API (although undocumented). Make it
   // lazily evalulate to Event from event_bindings.js. For extensions only
   // though, not all webpages!
   if (context->extension()) {
-    v8::Handle<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
+    v8::Local<v8::Object> chrome = AsObjectOrEmpty(GetOrCreateChrome(context));
     if (!chrome.IsEmpty())
       module_system->SetLazyField(chrome, "Event", kEventBindings, "Event");
   }
 
   UpdateBindingsForContext(context);
 
   bool is_within_platform_app = IsWithinPlatformApp();
   // Inject custom JS into the platform app context.
   if (is_within_platform_app) {
     module_system->Require("platformApp");
@@ skipping 29 matching lines @@
     case Feature::WEBUI_CONTEXT:
       UMA_HISTOGRAM_TIMES("Extensions.DidCreateScriptContext_WebUI", elapsed);
       break;
   }
 
   VLOG(1) << "Num tracked contexts: " << script_context_set_->size();
 }
 
 void Dispatcher::WillReleaseScriptContext(
     blink::WebLocalFrame* frame,
-    const v8::Handle<v8::Context>& v8_context,
+    const v8::Local<v8::Context>& v8_context,
     int world_id) {
   ScriptContext* context = script_context_set_->GetByV8Context(v8_context);
   if (!context)
     return;
 
   context->DispatchOnUnloadEvent();
   // TODO(kalman): Make |request_sender| use |context->AddInvalidationObserver|.
   // In fact |request_sender_| should really be owned by ScriptContext.
   request_sender_->InvalidateSource(context);
 
@@ skipping 854 matching lines @@
           RegisterBinding(api_name, context);
       }
       break;
     }
   }
 }
 
 void Dispatcher::RegisterBinding(const std::string& api_name,
                                  ScriptContext* context) {
   std::string bind_name;
-  v8::Handle<v8::Object> bind_object =
+  v8::Local<v8::Object> bind_object =
       GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
 
   // Empty if the bind object failed to be created, probably because the
   // extension overrode chrome with a non-object, e.g. window.chrome = true.
   if (bind_object.IsEmpty())
     return;
 
   v8::Local<v8::String> v8_bind_name =
       v8::String::NewFromUtf8(context->isolate(), bind_name.c_str());
   if (bind_object->HasRealNamedProperty(v8_bind_name)) {
@@ skipping 97 matching lines @@
   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
        iter != active_extension_ids_.end();
        ++iter) {
     const Extension* extension = extensions_.GetByID(*iter);
     if (extension && extension->is_platform_app())
       return true;
   }
   return false;
 }
 
-v8::Handle<v8::Object> Dispatcher::GetOrCreateObject(
-    const v8::Handle<v8::Object>& object,
+v8::Local<v8::Object> Dispatcher::GetOrCreateObject(
+    const v8::Local<v8::Object>& object,
     const std::string& field,
     v8::Isolate* isolate) {
-  v8::Handle<v8::String> key = v8::String::NewFromUtf8(isolate, field.c_str());
+  v8::Local<v8::String> key = v8::String::NewFromUtf8(isolate, field.c_str());
   // If the object has a callback property, it is assumed it is an unavailable
   // API, so it is safe to delete. This is checked before GetOrCreateObject is
   // called.
   if (object->HasRealNamedCallbackProperty(key)) {
     object->Delete(key);
   } else if (object->HasRealNamedProperty(key)) {
-    v8::Handle<v8::Value> value = object->Get(key);
+    v8::Local<v8::Value> value = object->Get(key);
     CHECK(value->IsObject());
-    return v8::Handle<v8::Object>::Cast(value);
+    return v8::Local<v8::Object>::Cast(value);
   }
 
-  v8::Handle<v8::Object> new_object = v8::Object::New(isolate);
+  v8::Local<v8::Object> new_object = v8::Object::New(isolate);
   object->Set(key, new_object);
   return new_object;
 }
 
-v8::Handle<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
+v8::Local<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
     const std::string& api_name,
     std::string* bind_name,
     ScriptContext* context) {
   std::vector<std::string> split;
   base::SplitString(api_name, '.', &split);
 
-  v8::Handle<v8::Object> bind_object;
+  v8::Local<v8::Object> bind_object;
 
   // Check if this API has an ancestor. If the API's ancestor is available and
   // the API is not available, don't install the bindings for this API. If
   // the API is available and its ancestor is not, delete the ancestor and
   // install the bindings for the API. This is to prevent loading the ancestor
   // API schema if it will not be needed.
   //
   // For example:
   //  If app is available and app.window is not, just install app.
   //  If app.window is available and app is not, delete app and install
   //  app.window on a new object so app does not have to be loaded.
   const FeatureProvider* api_feature_provider =
       FeatureProvider::GetAPIFeatures();
   std::string ancestor_name;
   bool only_ancestor_available = false;
 
   for (size_t i = 0; i < split.size() - 1; ++i) {
     ancestor_name += (i ? "." : "") + split[i];
     if (api_feature_provider->GetFeature(ancestor_name) &&
         context->GetAvailability(ancestor_name).is_available() &&
         !context->GetAvailability(api_name).is_available()) {
       only_ancestor_available = true;
       break;
     }
 
     if (bind_object.IsEmpty()) {
       bind_object = AsObjectOrEmpty(GetOrCreateChrome(context));
       if (bind_object.IsEmpty())
-        return v8::Handle<v8::Object>();
+        return v8::Local<v8::Object>();
     }
     bind_object = GetOrCreateObject(bind_object, split[i], context->isolate());
   }
 
   if (only_ancestor_available)
-    return v8::Handle<v8::Object>();
+    return v8::Local<v8::Object>();
 
   if (bind_name)
     *bind_name = split.back();
 
   return bind_object.IsEmpty() ? AsObjectOrEmpty(GetOrCreateChrome(context))
                                : bind_object;
 }
 
 void Dispatcher::RequireGuestViewModules(ScriptContext* context) {
   Feature::Context context_type = context->context_type();
@@ skipping 33 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions