Merge 86507 - 2011-05-15 Ilya Tikhonovsky <loislo@chromium.org>

Source/WebCore/inspector/CodeGeneratorInspector.pm

 # Copyright (c) 2010 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.
 
 package CodeGeneratorInspector;
 
 use strict;
 
 use Class::Struct;
 use File::stat;
@@ skipping 75 matching lines @@
     "domainAccessor" => "m_timelineAgent",
 };
 
 $typeTransform{"Frontend"} = {
     "forward" => "InspectorFrontend",
     "header" => "InspectorFrontend.h",
 };
 $typeTransform{"PassRefPtr"} = {
     "forwardHeader" => "wtf/PassRefPtr.h",
 };
+$typeTransform{"RefCounted"} = {
+    "forwardHeader" => "wtf/RefCounted.h",
+};
 $typeTransform{"InspectorFrontendChannel"} = {
     "forward" => "InspectorFrontendChannel",
     "header" => "InspectorFrontendChannel.h",
 };
 $typeTransform{"Object"} = {
     "param" => "PassRefPtr<InspectorObject>",
     "variable" => "RefPtr<InspectorObject>",
     "defaultValue" => "InspectorObject::create()",
     "forward" => "InspectorObject",
     "header" => "InspectorValues.h",
@@ skipping 100 matching lines @@
 
 my $codeGenerator;
 my $outputDir;
 my $outputHeadersDir;
 my $writeDependencies;
 my $verbose;
 
 my $namespace;
 
 my $backendClassName;
+my $backendClassDeclaration;
 my $backendJSStubName;
 my %backendTypes;
 my @backendMethods;
 my @backendMethodsImpl;
 my %backendMethodSignatures;
 my $backendConstructor;
 my @backendConstantDeclarations;
 my @backendConstantDefinitions;
 my @backendFooter;
 my @backendJSStubs;
@@ skipping 40 matching lines @@
 
     $frontendClassName = "InspectorFrontend";
     $frontendConstructor = "    ${frontendClassName}(InspectorFrontendChannel*);";
     push(@frontendFooter, "private:");
     push(@frontendFooter, "    InspectorFrontendChannel* m_inspectorFrontendChannel;");
     $frontendTypes{"String"} = 1;
     $frontendTypes{"InspectorFrontendChannel"} = 1;
     $frontendTypes{"PassRefPtr"} = 1;
 
     $backendClassName = "InspectorBackendDispatcher";
+    $backendClassDeclaration = "InspectorBackendDispatcher: public RefCounted<InspectorBackendDispatcher>";
     $backendJSStubName = "InspectorBackendStub";
     $backendTypes{"Inspector"} = 1;
     $backendTypes{"InspectorFrontendChannel"} = 1;
     $backendTypes{"PassRefPtr"} = 1;
+    $backendTypes{"RefCounted"} = 1;
     $backendTypes{"Object"} = 1;
 }
 
 # Params: 'idlDocument' struct
 sub GenerateInterface
 {
     my $object = shift;
     my $interface = shift;
     my $defines = shift;
 
@@ skipping 87 matching lines @@
     push(@function, "    ${functionName}Message->setString(\"method\", \"$domain.$functionName\");");
     if (scalar(@argsFiltered)) {
         push(@function, "    RefPtr<InspectorObject> paramsObject = InspectorObject::create();");
 
         foreach my $parameter (@argsFiltered) {
             my $optional = $parameter->extendedAttributes->{"optional"} ? "if (" . $parameter->name . ")\n        " : "";
             push(@function, "    " . $optional . "paramsObject->set" . typeTraits($parameter->type, "JSONType") . "(\"" . $parameter->name . "\", " . $parameter->name . ");");
         }
         push(@function, "    ${functionName}Message->setObject(\"params\", paramsObject);");
     }
-    push(@function, "    m_inspectorFrontendChannel->sendMessageToFrontend(${functionName}Message->toJSONString());");
+    push(@function, "    if (m_inspectorFrontendChannel)");
+    push(@function, "        m_inspectorFrontendChannel->sendMessageToFrontend(${functionName}Message->toJSONString());");
     push(@function, "}");
     push(@function, "");
     push(@frontendMethodsImpl, @function);
 }
 
 sub camelCase
 {
     my $value = shift;
     $value =~ s/\b(\w)/\U$1/g; # make a camel-case name for type name
     $value =~ s/ //g;
@@ skipping 84 matching lines @@
     push(@function, "        reportProtocolError(&callId, ServerError, error);");
     push(@function, "        return;");
     push(@function, "    }");
     push(@function, "");
     push(@function, "    RefPtr<InspectorObject> responseMessage = InspectorObject::create();");
     push(@function, "    RefPtr<InspectorObject> result = InspectorObject::create();");
     push(@function, map("        result->set" . typeTraits($_->type, "JSONType") . "(\"" . $_->name . "\", out_" . $_->name . ");", @outArgs));
     push(@function, "    responseMessage->setObject(\"result\", result);");
     push(@function, "");
     push(@function, "    responseMessage->setNumber(\"id\", callId);");
-    push(@function, "    m_inspectorFrontendChannel->sendMessageToFrontend(responseMessage->toJSONString());");
+    push(@function, "    if (m_inspectorFrontendChannel)");
+    push(@function, "        m_inspectorFrontendChannel->sendMessageToFrontend(responseMessage->toJSONString());");
     push(@function, "}");
     push(@function, "");
     push(@backendMethodsImpl, @function);
 }
 
 sub generateBackendReportProtocolError
 {
     my $reportProtocolError = << "EOF";
 
 void ${backendClassName}::reportProtocolError(const long* const callId, CommonErrorCode code, const String& customText) const
@@ skipping 20 matching lines @@
     ASSERT(InspectorObject::parseJSON(s_commonErrors[code]));
     RefPtr<InspectorObject> error = InspectorObject::parseJSON(s_commonErrors[code])->asObject();
     ASSERT(error);
     error->setArray("data", data);
     RefPtr<InspectorObject> message = InspectorObject::create();
     message->setObject("error", error);
     if (callId)
         message->setNumber("id", *callId);
     else
         message->setValue("id", InspectorValue::null());
-    m_inspectorFrontendChannel->sendMessageToFrontend(message->toJSONString());
+    if (m_inspectorFrontendChannel)
+        m_inspectorFrontendChannel->sendMessageToFrontend(message->toJSONString());
 }
 EOF
     return split("\n", $reportProtocolError);
 }
 
 sub generateArgumentGetters
 {
     my $type = shift;
     my $json = typeTraits($type, "JSONType");
     my $variable = typeTraits($type, "variable");
@@ skipping 30 matching lines @@
 
 sub generateBackendDispatcher
 {
     my @body;
     my @mapEntries = map("        dispatchMap.add(${_}Cmd, &${backendClassName}::$_);", map ($backendMethodSignatures{$_}, @backendMethods));
     my $mapEntries = join("\n", @mapEntries);
 
     my $backendDispatcherBody = << "EOF";
 void ${backendClassName}::dispatch(const String& message)
 {
+    RefPtr<${backendClassName}> protect = this;
     typedef void (${backendClassName}::*CallHandler)(long callId, InspectorObject* messageObject);
     typedef HashMap<String, CallHandler> DispatchMap;
     DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, );
     long callId = 0;
 
     if (dispatchMap.isEmpty()) {
 $mapEntries
     }
 
     RefPtr<InspectorValue> parsedMessage = InspectorValue::parseJSON(message);
@@ skipping 279 matching lines @@
 
 InspectorBackend = new InspectorBackendStub();
 
 EOF
     return split("\n", $inspectorBackendStubJS);
 }
 
 sub generateHeader
 {
     my $className = shift;
+    my $classDeclaration = shift;
     my $types = shift;
     my $constructor = shift;
     my $constants = shift;
     my $methods = shift;
     my $footer = shift;
 
     my $forwardHeaders = join("\n", sort(map("#include <" . typeTraits($_, "forwardHeader") . ">", grep(typeTraits($_, "forwardHeader"), keys %{$types}))));
     my $forwardDeclarations = join("\n", sort(map("class " . typeTraits($_, "forward") . ";", grep(typeTraits($_, "forward"), keys %{$types}))));
     my $constantDeclarations = join("\n", @{$constants});
     my $methodsDeclarations = join("\n", @{$methods});
 
     my $headerBody = << "EOF";
 // Copyright (c) 2010 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.
 #ifndef ${className}_h
 #define ${className}_h
 
 ${forwardHeaders}
 
 namespace $namespace {
 
 $forwardDeclarations
 
 typedef String ErrorString;
 
-class $className {
+class $classDeclaration {
 public:
 $constructor
 
 $constantDeclarations
 $methodsDeclarations
 
 $footer
 };
 
 } // namespace $namespace
@@ skipping 66 matching lines @@
         push(@arguments, "${agentClassName}* ${arg}");
     }
 
     my $argumentString = join(", ", @arguments);
 
     my @backendHead;
     push(@backendHead, "    ${backendClassName}(${argumentString})");
     push(@backendHead, @fieldInitializers);
     push(@backendHead, "    { }");
     push(@backendHead, "");
+    push(@backendHead, "    void clearFrontend() { m_inspectorFrontendChannel = 0; }");
+    push(@backendHead, "");
     push(@backendHead, "    enum CommonErrorCode {");
     push(@backendHead, "        ParseError = 0,");
     push(@backendHead, "        InvalidRequest,");
     push(@backendHead, "        MethodNotFound,");
     push(@backendHead, "        InvalidParams,");
     push(@backendHead, "        InternalError,");
     push(@backendHead, "        ServerError,");
     push(@backendHead, "        LastEntry,");
     push(@backendHead, "    };");
     push(@backendHead, "");
@@ skipping 11 matching lines @@
     push(@backendMethodsImpl, generateBackendDispatcher());
     push(@backendMethodsImpl, generateBackendReportProtocolError());
     unshift(@frontendMethodsImpl, generateFrontendConstructorImpl(), "");
 
     open(my $SOURCE, ">$outputDir/$frontendClassName.cpp") || die "Couldn't open file $outputDir/$frontendClassName.cpp";
     print $SOURCE join("\n", generateSource($frontendClassName, \%frontendTypes, \@frontendConstantDefinitions, \@frontendMethodsImpl));
     close($SOURCE);
     undef($SOURCE);
 
     open(my $HEADER, ">$outputHeadersDir/$frontendClassName.h") || die "Couldn't open file $outputHeadersDir/$frontendClassName.h";
-    print $HEADER generateHeader($frontendClassName, \%frontendTypes, $frontendConstructor, \@frontendConstantDeclarations, \@frontendMethods, join("\n", @frontendFooter));
+    print $HEADER generateHeader($frontendClassName, $frontendClassName, \%frontendTypes, $frontendConstructor, \@frontendConstantDeclarations, \@frontendMethods, join("\n", @frontendFooter));
     close($HEADER);
     undef($HEADER);
 
     # Make dispatcher methods private on the backend.
     push(@backendConstantDeclarations, "");
     push(@backendConstantDeclarations, "private:");
 
     foreach my $type (keys %backendTypes) {
         if (typeTraits($type, "JSONType")) {
             push(@backendMethodsImpl, generateArgumentGetters($type));
         }
     }
     generateBackendAgentFieldsAndConstructor();
 
     push(@backendMethodsImpl, generateBackendMessageParser());
     push(@backendMethodsImpl, "");
 
     push(@backendConstantDeclarations, "");
 
     open($SOURCE, ">$outputDir/$backendClassName.cpp") || die "Couldn't open file $outputDir/$backendClassName.cpp";
     print $SOURCE join("\n", generateSource($backendClassName, \%backendTypes, \@backendConstantDefinitions, \@backendMethodsImpl));
     close($SOURCE);
     undef($SOURCE);
 
     open($HEADER, ">$outputHeadersDir/$backendClassName.h") || die "Couldn't open file $outputHeadersDir/$backendClassName.h";
-    print $HEADER join("\n", generateHeader($backendClassName, \%backendTypes, $backendConstructor, \@backendConstantDeclarations, \@backendMethods, join("\n", @backendFooter)));
+    print $HEADER join("\n", generateHeader($backendClassName, $backendClassDeclaration, \%backendTypes, $backendConstructor, \@backendConstantDeclarations, \@backendMethods, join("\n", @backendFooter)));
     close($HEADER);
     undef($HEADER);
 
     open(my $JS_STUB, ">$outputDir/$backendJSStubName.js") || die "Couldn't open file $outputDir/$backendJSStubName.js";
     print $JS_STUB join("\n", generateBackendStubJS());
     close($JS_STUB);
     undef($JS_STUB);
 }
 
 1;