Generate a bit less code to handle failed arity checks.

Source/bindings/v8/ExceptionState.cpp

 /*
  * 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 65 matching lines @@
     m_exception.set(m_isolate, exception);
 }
 
 void ExceptionState::throwTypeError(const String& message)
 {
     ASSERT(m_isolate);
     m_code = TypeError;
     setException(V8ThrowException::createTypeError(addExceptionContext(message), m_isolate));
 }
 
+void ExceptionState::notEnoughArguments(int expected, int actual)
+{
+    throwTypeError(ExceptionMessages::notEnoughArguments(expected, actual));
+    throwIfNeeded();

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

This is a change from the semantics we've set up for ExceptionState. Generally,
we pass the state somewhere, allow that somewhere to queue up an exception, and
then _actually_ throw the exception when we get back to bindings.

I'd prefer to keep that implicit contract, even if it means that throwing
exceptions _from_ bindings is a bit more verbose.

[sof, 2013/12/05 12:01:32]

It seems redundant to generate that much code at each site doing an arity check.

Contract expectations can be accounted for by naming, I think. I didn't prefix
"throw" as it isn't throwing a non-existent NotEnoughArguments exception.
Perhaps "report" or some such would be clearer.

[Mike West, 2013/12/05 12:15:15]

As long as we can assume that this is always called in the same context in which
the ExceptionState was created, I agree with you. If I pass 'exceptionState'
into a function, however, I don't want a situation where 'throwIfNeeded' might
be called both by the callee and the caller.
 
Sure. This comes back to one of the other questions. When do we want the
callsite to call 'throwDOMException' or 'throwTypeException' with an appropriate
message, and when do we want to wrap those to set the message implicitly?

+}
+
 void TrackExceptionState::throwDOMException(const ExceptionCode& ec, const String& message)
 {
     m_code = ec;
 }
 
 void TrackExceptionState::throwTypeError(const String&)
 {
     m_code = TypeError;
 }
 
@@ skipping 17 matching lines @@
             processedMessage = ExceptionMessages::failedToGet(propertyName(), interfaceName(), message);
         else if (m_context == SetterContext)
             processedMessage = ExceptionMessages::failedToSet(propertyName(), interfaceName(), message);
     } else if (!propertyName() && interfaceName() && m_context == ConstructionContext) {
         processedMessage = ExceptionMessages::failedToConstruct(interfaceName(), message);
     }
     return processedMessage;
 }
 
 } // namespace WebCore