Add 'stream' to XMLHttpRequest response type.

Source/core/streams/ReadableStreamImpl.h

 // Copyright 2014 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 ReadableStreamImpl_h
 #define ReadableStreamImpl_h
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
@@ skipping 24 matching lines @@
         return ScriptValue(scriptState, v8String(scriptState->isolate(), value));
     }
 };
 
 template<>
 class ReadableStreamChunkTypeTraits<ArrayBuffer> {
 public:
     typedef RefPtr<ArrayBuffer> HoldType;
     typedef PassRefPtr<ArrayBuffer> PassType;
 
-    static size_t size(PassType value) { return value->byteLength(); }
+    static size_t size(const PassType& value) { return value->byteLength(); }
     static size_t size(const HoldType& value) { return value->byteLength(); }
     static ScriptValue toScriptValue(ScriptState* scriptState, const HoldType& value)
     {
         return ScriptValue(scriptState, toV8NoInline(value.get(), scriptState->context()->Global(), scriptState->isolate()));
     }
 };
 
 // ReadableStreamImpl<ChunkTypeTraits> is a ReadableStream subtype. It has a
 // queue whose type depends on ChunkTypeTraits and it implements queue-related
 // ReadableStream pure virtual methods.
 template <typename ChunkTypeTraits>
 class ReadableStreamImpl : public ReadableStream {
 public:
-    ReadableStreamImpl(ScriptState* scriptState, UnderlyingSource* source, ExceptionState* exceptionState)
-        : ReadableStream(scriptState, source, exceptionState)
+    ReadableStreamImpl(ExecutionContext* executionContext, UnderlyingSource* source)
+        : ReadableStream(executionContext, source)
         , m_totalQueueSize(0) { }
     virtual ~ReadableStreamImpl() { }
 
     // ReadableStream methods
-    virtual ScriptValue read(ScriptState*, ExceptionState*) OVERRIDE;
+    virtual ScriptValue read(ScriptState*, ExceptionState&) OVERRIDE;
 
     bool enqueue(typename ChunkTypeTraits::PassType);
 
     virtual void trace(Visitor* visitor) OVERRIDE
     {
         ReadableStream::trace(visitor);
     }
 
 private:
     // ReadableStream methods
@@ skipping 13 matching lines @@
 {
     size_t size = ChunkTypeTraits::size(chunk);
     if (!enqueuePreliminaryCheck(size))
         return false;
     m_queue.append(chunk);
     m_totalQueueSize += size;
     return enqueuePostAction(m_totalQueueSize);
 }
 
 template <typename ChunkTypeTraits>
-ScriptValue ReadableStreamImpl<ChunkTypeTraits>::read(ScriptState* scriptState, ExceptionState* exceptionState)
+ScriptValue ReadableStreamImpl<ChunkTypeTraits>::read(ScriptState* scriptState, ExceptionState& exceptionState)
 {
     readPreliminaryCheck(exceptionState);
-    if (exceptionState->hadException())
+    if (exceptionState.hadException())
         return ScriptValue();
     ASSERT(state() == Readable);
     ASSERT(!m_queue.isEmpty());
     typename ChunkTypeTraits::HoldType chunk = m_queue.takeFirst();
     m_totalQueueSize -= ChunkTypeTraits::size(chunk);
     readPostAction();
     return ChunkTypeTraits::toScriptValue(scriptState, chunk);
 }
 
 } // namespace blink
 
 #endif // ReadableStreamImpl_h