Generate a bit less code to handle failed arity checks.

Source/bindings/v8/ExceptionState.h

 /*
  * 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
@@ skipping 63 matching lines @@
         , m_context(context)
         , m_propertyName(0)
         , m_interfaceName(interfaceName)
         , m_creationContext(creationContext)
         , m_isolate(isolate) { ASSERT(m_context == ConstructionContext); }
 
     virtual void throwDOMException(const ExceptionCode&, const String& message);
     virtual void throwTypeError(const String& message);
     virtual void throwSecurityError(const String& sanitizedMessage, const String& unsanitizedMessage = String());
 
+    // Throw a TypeError if too few arguments were supplied.
+    void notEnoughArguments(int expected, int actual);

[Mike West, 2013/12/05 11:48:59]

Hrm. 

1. This should have "throw" in the name.
2. Does this provide enough value to stand alone? I'm wondering where the line
is between "throwTypeError(ExceptionMessages::xxx(...))" and
"throwXXXError(...)". Are we going to end up with 10s of methods on
ExceptionState?

[sof, 2013/12/09 22:53:20]

(FTR, there are currently 484 applications of this in the generated bindings
code.)

If the concern is that having helpers like this will make the general use(r) of
ExceptionState too hard to work with, then the class system could naturally be
used to separate the two different uses of it.

Anyway, with it being suggested that this arity-check helper shouldn't also do
the 'real' throw by calling throwIfNeeded(), the case for introducing one here
does indeed fall away. I've taken it out.

+
     // Please don't use these methods. Use ::throwDOMException and ::throwTypeError, and pass in a useful exception message.
     virtual void throwUninformativeAndGenericDOMException(const ExceptionCode& ec) { throwDOMException(ec, String()); }
     virtual void throwUninformativeAndGenericTypeError() { throwTypeError(String()); }
 
     bool hadException() const { return !m_exception.isEmpty() || m_code; }
     void clearException();
 
     ExceptionCode code() const { return m_code; }
 
     bool throwIfNeeded()
@@ skipping 32 matching lines @@
 public:
     TrackExceptionState(): ExceptionState(v8::Handle<v8::Object>(), 0) { }
     virtual void throwDOMException(const ExceptionCode&, const String& message) OVERRIDE FINAL;
     virtual void throwTypeError(const String& message = String()) OVERRIDE FINAL;
     virtual void throwSecurityError(const String& sanitizedMessage, const String& unsanitizedMessage = String()) OVERRIDE FINAL;
 };
 
 } // namespace WebCore
 
 #endif // ExceptionState_h