Remove ExceptionState::throwIfNeeded

third_party/WebKit/Source/bindings/core/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 19 matching lines @@
 
 #include "bindings/core/v8/ExceptionState.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/ExceptionCode.h"
 
 namespace blink {
 
+ExceptionState::~ExceptionState()
+{
+    if (!m_exception.isEmpty())
+        throwException();
+}
+
 void ExceptionState::clearException()
 {
     m_code = 0;
     m_exception.clear();
 }
 
 ScriptPromise ExceptionState::reject(ScriptState* scriptState)
 {
     ScriptPromise promise = ScriptPromise::reject(scriptState, m_exception.newLocal(scriptState->isolate()));
     clearException();
@@ skipping 41 matching lines @@
         return;
     }
 
     m_exception.set(m_isolate, exception);
 }
 
 void ExceptionState::throwException()
 {
     ASSERT(!m_exception.isEmpty());
     V8ThrowException::throwException(m_exception.newLocal(m_isolate), m_isolate);
+    clearException();

[Yuki, 2016/06/15 07:23:25]

Why do you need this line?

throwException() is a private member function, and only the call site is the
destructor.  It seems more efficient to let the destructor of ScopedPersistent
clears things.

If it makes something clearer, I'd migrate the implementation of
throwException() into the destructor so that it's clear that no one else throws.
 Then, it's obvious that there is no need to do clearException().

 }
 
 void ExceptionState::throwTypeError(const String& message)
 {
     ASSERT(m_isolate);
     m_code = V8TypeError;
     m_message = message;
     setException(V8ThrowException::createTypeError(m_isolate, addExceptionContext(message)));
 }
 
@@ skipping 81 matching lines @@
             processedMessage = ExceptionMessages::failedToDeleteIndexed(interfaceName(), message);
         else if (m_context == IndexedGetterContext)
             processedMessage = ExceptionMessages::failedToGetIndexed(interfaceName(), message);
         else if (m_context == IndexedSetterContext)
             processedMessage = ExceptionMessages::failedToSetIndexed(interfaceName(), message);
     }
     return processedMessage;
 }
 
 } // namespace blink