Move IDLs to 39 roll

core/inspector/CodeGeneratorInspectorStrings.py

 # Copyright (c) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 52 matching lines @@
 frontend_method = ("""void InspectorFrontend::$domainName::$eventName($parameters)
 {
     RefPtr<JSONObject> jsonMessage = JSONObject::create();
     jsonMessage->setString("method", "$domainName.$eventName");
 $code    if (m_inspectorFrontendChannel)
         m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage.release());
 }
 """)
 
 callback_main_methods = (
-"""InspectorBackendDispatcher::$agentName::$callbackName::$callbackName(PassRefPtr<InspectorBackendDispatcherImpl> backendImpl, int id) : CallbackBase(backendImpl, id) {}
+"""InspectorBackendDispatcher::$agentName::$callbackName::$callbackName(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id) : CallbackBase(backendImpl, id) {}
 
 void InspectorBackendDispatcher::$agentName::$callbackName::sendSuccess($parameters)
 {
     RefPtr<JSONObject> jsonMessage = JSONObject::create();
 $code    sendIfActive(jsonMessage, ErrorString(), PassRefPtr<JSONValue>());
 }
 """)
 
 callback_failure_method = (
 """void InspectorBackendDispatcher::$agentName::$callbackName::sendFailure(const ErrorString& error, $parameter)
@@ skipping 35 matching lines @@
 } // namespace blink
 #endif // !defined(InspectorFrontend_h)
 """)
 
 backend_h = (
 """#ifndef InspectorBackendDispatcher_h
 #define InspectorBackendDispatcher_h
 
 #include "InspectorTypeBuilder.h"
 
+#include "platform/heap/Handle.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class JSONObject;
 class JSONArray;
 class InspectorFrontendChannel;
 
 typedef String ErrorString;
 
 class InspectorBackendDispatcherImpl;
 
-class InspectorBackendDispatcher: public RefCounted<InspectorBackendDispatcher> {
+class InspectorBackendDispatcher: public RefCountedWillBeGarbageCollectedFinalized<InspectorBackendDispatcher> {
 public:
-    static PassRefPtr<InspectorBackendDispatcher> create(InspectorFrontendChannel* inspectorFrontendChannel);
+    static PassRefPtrWillBeRawPtr<InspectorBackendDispatcher> create(InspectorFrontendChannel* inspectorFrontendChannel);
     virtual ~InspectorBackendDispatcher() { }
+    virtual void trace(Visitor*) { }
 
-    class CallbackBase: public RefCounted<CallbackBase> {
+    class CallbackBase: public RefCountedWillBeGarbageCollectedFinalized<CallbackBase> {
     public:
-        CallbackBase(PassRefPtr<InspectorBackendDispatcherImpl> backendImpl, int id);
+        CallbackBase(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id);
         virtual ~CallbackBase();
+        virtual void trace(Visitor*);
         void sendFailure(const ErrorString&);
         bool isActive();
 
     protected:
         void sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData);
 
     private:
         void disable() { m_alreadySent = true; }
 
-        RefPtr<InspectorBackendDispatcherImpl> m_backendImpl;
+        RefPtrWillBeMember<InspectorBackendDispatcherImpl> m_backendImpl;
         int m_id;
         bool m_alreadySent;
 
         friend class InspectorBackendDispatcherImpl;
     };
 
 $agentInterfaces
 $virtualSetters
 
     virtual void clearFrontend() = 0;
@@ skipping 99 matching lines @@
     {
         sendResponse(callId, invocationError, RefPtr<JSONValue>(), JSONObject::create());
     }
     static const char InvalidParamsFormatString[];
 };
 
 const char InspectorBackendDispatcherImpl::InvalidParamsFormatString[] = "Some arguments of method '%s' can't be processed";
 
 $methods
 
-PassRefPtr<InspectorBackendDispatcher> InspectorBackendDispatcher::create(InspectorFrontendChannel* inspectorFrontendChannel)
+PassRefPtrWillBeRawPtr<InspectorBackendDispatcher> InspectorBackendDispatcher::create(InspectorFrontendChannel* inspectorFrontendChannel)
 {
-    return adoptRef(new InspectorBackendDispatcherImpl(inspectorFrontendChannel));
+    return adoptRefWillBeNoop(new InspectorBackendDispatcherImpl(inspectorFrontendChannel));
 }
 
 
 void InspectorBackendDispatcherImpl::dispatch(const String& message)
 {
-    RefPtr<InspectorBackendDispatcher> protect = this;
+    RefPtrWillBeRawPtr<InspectorBackendDispatcher> protect(this);
     typedef void (InspectorBackendDispatcherImpl::*CallHandler)(long callId, JSONObject* messageObject, JSONArray* protocolErrors);
     typedef HashMap<String, CallHandler> DispatchMap;
     DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, );
     long callId = 0;
 
     if (dispatchMap.isEmpty()) {
         static const CallHandler handlers[] = {
 $messageHandlers
         };
         for (size_t i = 0; i < kMethodNamesEnumSize; ++i)
@@ skipping 177 matching lines @@
     RefPtr<JSONObject> object = value->asObject();
     if (!object)
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
-InspectorBackendDispatcher::CallbackBase::CallbackBase(PassRefPtr<InspectorBackendDispatcherImpl> backendImpl, int id)
+InspectorBackendDispatcher::CallbackBase::CallbackBase(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id)
     : m_backendImpl(backendImpl), m_id(id), m_alreadySent(false) {}
 
 InspectorBackendDispatcher::CallbackBase::~CallbackBase() {}
 
+void InspectorBackendDispatcher::CallbackBase::trace(Visitor* visitor)
+{
+    visitor->trace(m_backendImpl);
+}
+
 void InspectorBackendDispatcher::CallbackBase::sendFailure(const ErrorString& error)
 {
     ASSERT(error.length());
     sendIfActive(nullptr, error, PassRefPtr<JSONValue>());
 }
 
 bool InspectorBackendDispatcher::CallbackBase::isActive()
 {
     return !m_alreadySent && m_backendImpl->isActive();
 }
@@ skipping 67 matching lines @@
         return m_value;
     }
 
 private:
     T m_value;
     bool m_assigned;
 
     WTF_MAKE_NONCOPYABLE(OptOutput);
 };
 
-
-// A small transient wrapper around int type, that can be used as a funciton parameter type
-// cleverly disallowing C++ implicit casts from float or double.
-class ExactlyInt {
-public:
-    template<typename T>
-    ExactlyInt(T t) : m_value(cast_to_int<T>(t)) {}
-
-    ExactlyInt() {}
-
-    operator int() { return m_value; }
-private:
-    int m_value;
-
-    template<typename T>
-    static int cast_to_int(T) { return T::default_case_cast_is_not_supported(); }
-};
-
-template<>
-inline int ExactlyInt::cast_to_int<int>(int i) { return i; }
-
-template<>
-inline int ExactlyInt::cast_to_int<unsigned int>(unsigned int i) { return i; }
-
 class RuntimeCastHelper {
 public:
 #if $validatorIfdefName
     template<JSONValue::Type TYPE>
     static void assertType(JSONValue* value)
     {
         ASSERT(value->type() == TYPE);
     }
     static void assertAny(JSONValue*);
     static void assertInt(JSONValue* value);
@@ skipping 333 matching lines @@
     };
 
 """)
 
 class_binding_builder_part_4 = (
 """    static Builder<NoFieldsSet> create()
     {
         return Builder<NoFieldsSet>(JSONObject::create());
     }
 """)