Remove usage of deprecated V8 APIs from c/r/extensions

chrome/renderer/extensions/event_bindings.cc

 // Copyright (c) 2012 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 "chrome/renderer/extensions/event_bindings.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 79 matching lines @@
                    base::Unretained(this)));
   }
 
   virtual ~ExtensionImpl() {}
 
   // Attach an event name to an object.
   void AttachEvent(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK_EQ(1, args.Length());
     CHECK(args[0]->IsString());
 
-    std::string event_name = *v8::String::AsciiValue(args[0]->ToString());
+    std::string event_name = *v8::String::Utf8Value(args[0]->ToString());
 
     if (!dispatcher_->CheckContextAccessToExtensionAPI(event_name, context()))
       return;
 
     std::string extension_id = context()->GetExtensionID();
     EventListenerCounts& listener_counts =
         g_listener_counts.Get()[extension_id];
     if (++listener_counts[event_name] == 1) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_AddListener(extension_id, event_name));
     }
 
     // This is called the first time the page has added a listener. Since
     // the background page is the only lazy page, we know this is the first
     // time this listener has been registered.
     if (IsLazyBackgroundPage(GetRenderView(), context()->extension())) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_AddLazyListener(extension_id, event_name));
     }
   }
 
   void DetachEvent(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK_EQ(2, args.Length());
     CHECK(args[0]->IsString());
     CHECK(args[1]->IsBoolean());
 
-    std::string event_name = *v8::String::AsciiValue(args[0]);
+    std::string event_name = *v8::String::Utf8Value(args[0]);
     bool is_manual = args[1]->BooleanValue();
 
     std::string extension_id = context()->GetExtensionID();
     EventListenerCounts& listener_counts =
         g_listener_counts.Get()[extension_id];
 
     if (--listener_counts[event_name] == 0) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_RemoveListener(extension_id, event_name));
     }
@@ skipping 12 matching lines @@
   // MatcherID AttachFilteredEvent(string event_name, object filter)
   // event_name - Name of the event to attach.
   // filter - Which instances of the named event are we interested in.
   // returns the id assigned to the listener, which will be returned from calls
   // to MatchAgainstEventFilter where this listener matches.
   void AttachFilteredEvent(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK_EQ(2, args.Length());
     CHECK(args[0]->IsString());
     CHECK(args[1]->IsObject());
 
-    std::string event_name = *v8::String::AsciiValue(args[0]);
+    std::string event_name = *v8::String::Utf8Value(args[0]);
 
     // This method throws an exception if it returns false.
     if (!dispatcher_->CheckContextAccessToExtensionAPI(event_name, context()))
       return;
 
     std::string extension_id = context()->GetExtensionID();
     if (extension_id.empty()) {
       args.GetReturnValue().Set(static_cast<int32_t>(-1));
       return;
     }
@@ skipping 90 matching lines @@
                                                       lazy));
     }
 
     event_filter.RemoveEventMatcher(matcher_id);
   }
 
   void MatchAgainstEventFilter(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     typedef std::set<EventFilter::MatcherID> MatcherIDs;
     EventFilter& event_filter = g_event_filter.Get();
-    std::string event_name = *v8::String::AsciiValue(args[0]->ToString());
+    std::string event_name = *v8::String::Utf8Value(args[0]->ToString());
     EventFilteringInfo info =
         ParseFromObject(args[1]->ToObject(), args.GetIsolate());
     // Only match events routed to this context's RenderView or ones that don't
     // have a routingId in their filter.
     MatcherIDs matched_event_filters = event_filter.MatchEvent(
         event_name, info, context()->GetRenderView()->GetRoutingID());
-    v8::Handle<v8::Array> array(v8::Array::New(matched_event_filters.size()));
+    v8::Handle<v8::Array> array(
+        v8::Array::New(args.GetIsolate(), matched_event_filters.size()));
     int i = 0;
     for (MatcherIDs::iterator it = matched_event_filters.begin();
          it != matched_event_filters.end(); ++it) {
       array->Set(v8::Integer::New(i++), v8::Integer::New(*it));
     }
     args.GetReturnValue().Set(array);
   }
 
   static EventFilteringInfo ParseFromObject(v8::Handle<v8::Object> object,
                                             v8::Isolate* isolate) {
     EventFilteringInfo info;
     v8::Handle<v8::String> url(v8::String::NewFromUtf8(isolate, "url"));
     if (object->Has(url)) {
       v8::Handle<v8::Value> url_value(object->Get(url));
-      info.SetURL(GURL(*v8::String::AsciiValue(url_value)));
+      info.SetURL(GURL(*v8::String::Utf8Value(url_value)));
     }
     v8::Handle<v8::String> instance_id(
         v8::String::NewFromUtf8(isolate, "instanceId"));
     if (object->Has(instance_id)) {
       v8::Handle<v8::Value> instance_id_value(object->Get(instance_id));
       info.SetInstanceID(instance_id_value->IntegerValue());
     }
     v8::Handle<v8::String> service_type(
         v8::String::NewFromUtf8(isolate, "serviceType"));
     if (object->Has(service_type)) {
       v8::Handle<v8::Value> service_type_value(object->Get(service_type));
-      info.SetServiceType(*v8::String::AsciiValue(service_type_value));
+      info.SetServiceType(*v8::String::Utf8Value(service_type_value));
     }
     return info;
   }
 
  private:
   static bool IsLazyBackgroundPage(content::RenderView* render_view,
                                    const Extension* extension) {
     if (!render_view)
       return false;
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
@@ skipping 11 matching lines @@
 
 }  // namespace
 
 // static
 ChromeV8Extension* EventBindings::Create(Dispatcher* dispatcher,
                                          ChromeV8Context* context) {
   return new ExtensionImpl(dispatcher, context);
 }
 
 }  // namespace extensions