1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/message_loop/message_loop.h" 6 #include "base/test/test_simple_task_runner.h" 7 #include "content/browser/streams/stream.h" 8 #include "content/browser/streams/stream_read_observer.h" 9 #include "content/browser/streams/stream_registry.h" 10 #include "content/browser/streams/stream_write_observer.h" 11 #include "testing/gtest/include/gtest/gtest.h" 12 13 namespace content { 14 15 class StreamTest : public testing::Test { 16 public: 17 StreamTest() : producing_seed_key_(0) {} 18 19 virtual void SetUp() OVERRIDE { 20 registry_.reset(new StreamRegistry()); 21 } 22 23 // Create a new IO buffer of the given |buffer_size| and fill it with random 24 // data. 25 scoped_refptr<net::IOBuffer> NewIOBuffer(size_t buffer_size) { 26 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(buffer_size)); 27 char *bufferp = buffer->data(); 28 for (size_t i = 0; i < buffer_size; i++) 29 bufferp[i] = (i + producing_seed_key_) % (1 << sizeof(char)); 30 ++producing_seed_key_; 31 return buffer; 32 } 33 34 protected: 35 base::MessageLoop message_loop_; 36 scoped_ptr<StreamRegistry> registry_; 37 38 private: 39 int producing_seed_key_; 40 }; 41 42 class TestStreamReader : public StreamReadObserver { 43 public: 44 TestStreamReader() : buffer_(new net::GrowableIOBuffer()), completed_(false) { 45 } 46 virtual ~TestStreamReader() {} 47 48 void Read(Stream* stream) { 49 const size_t kBufferSize = 32768; 50 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize)); 51 52 int bytes_read = 0; 53 while (true) { 54 Stream::StreamState state = 55 stream->ReadRawData(buffer.get(), kBufferSize, &bytes_read); 56 switch (state) { 57 case Stream::STREAM_HAS_DATA: 58 // TODO(tyoshino): Move these expectations to the beginning of Read() 59 // method once Stream::Finalize() is fixed. 60 EXPECT_FALSE(completed_); 61 break; 62 case Stream::STREAM_COMPLETE: 63 completed_ = true; 64 return; 65 case Stream::STREAM_EMPTY: 66 EXPECT_FALSE(completed_); 67 return; 68 case Stream::STREAM_ABORTED: 69 EXPECT_FALSE(completed_); 70 return; 71 } 72 size_t old_capacity = buffer_->capacity(); 73 buffer_->SetCapacity(old_capacity + bytes_read); 74 memcpy(buffer_->StartOfBuffer() + old_capacity, 75 buffer->data(), bytes_read); 76 } 77 } 78 79 virtual void OnDataAvailable(Stream* stream) OVERRIDE { 80 Read(stream); 81 } 82 83 scoped_refptr<net::GrowableIOBuffer> buffer() { return buffer_; } 84 85 bool completed() const { 86 return completed_; 87 } 88 89 private: 90 scoped_refptr<net::GrowableIOBuffer> buffer_; 91 bool completed_; 92 }; 93 94 class TestStreamWriter : public StreamWriteObserver { 95 public: 96 TestStreamWriter() {} 97 virtual ~TestStreamWriter() {} 98 99 void Write(Stream* stream, 100 scoped_refptr<net::IOBuffer> buffer, 101 size_t buffer_size) { 102 stream->AddData(buffer, buffer_size); 103 } 104 105 virtual void OnSpaceAvailable(Stream* stream) OVERRIDE { 106 } 107 108 virtual void OnClose(Stream* stream) OVERRIDE { 109 } 110 }; 111 112 TEST_F(StreamTest, SetReadObserver) { 113 TestStreamReader reader; 114 TestStreamWriter writer; 115 116 GURL url("blob://stream"); 117 scoped_refptr<Stream> stream( 118 new Stream(registry_.get(), &writer, url)); 119 EXPECT_TRUE(stream->SetReadObserver(&reader)); 120 } 121 122 TEST_F(StreamTest, SetReadObserver_SecondFails) { 123 TestStreamReader reader1; 124 TestStreamReader reader2; 125 TestStreamWriter writer; 126 127 GURL url("blob://stream"); 128 scoped_refptr<Stream> stream( 129 new Stream(registry_.get(), &writer, url)); 130 EXPECT_TRUE(stream->SetReadObserver(&reader1)); 131 EXPECT_FALSE(stream->SetReadObserver(&reader2)); 132 } 133 134 TEST_F(StreamTest, SetReadObserver_TwoReaders) { 135 TestStreamReader reader1; 136 TestStreamReader reader2; 137 TestStreamWriter writer; 138 139 GURL url("blob://stream"); 140 scoped_refptr<Stream> stream( 141 new Stream(registry_.get(), &writer, url)); 142 EXPECT_TRUE(stream->SetReadObserver(&reader1)); 143 144 // Once the first read observer is removed, a new one can be added. 145 stream->RemoveReadObserver(&reader1); 146 EXPECT_TRUE(stream->SetReadObserver(&reader2)); 147 } 148 149 TEST_F(StreamTest, Stream) { 150 TestStreamReader reader; 151 TestStreamWriter writer; 152 153 GURL url("blob://stream"); 154 scoped_refptr<Stream> stream( 155 new Stream(registry_.get(), &writer, url)); 156 EXPECT_TRUE(stream->SetReadObserver(&reader)); 157 158 const int kBufferSize = 1000000; 159 scoped_refptr<net::IOBuffer> buffer(NewIOBuffer(kBufferSize)); 160 writer.Write(stream.get(), buffer, kBufferSize); 161 stream->Finalize(); 162 base::MessageLoop::current()->RunUntilIdle(); 163 EXPECT_TRUE(reader.completed()); 164 165 ASSERT_EQ(reader.buffer()->capacity(), kBufferSize); 166 for (int i = 0; i < kBufferSize; i++) 167 EXPECT_EQ(buffer->data()[i], reader.buffer()->data()[i]); 168 } 169 170 // Test that even if a reader receives an empty buffer, once TransferData() 171 // method is called on it with |source_complete| = true, following Read() calls 172 // on it never returns STREAM_EMPTY. Together with StreamTest.Stream above, this 173 // guarantees that Reader::Read() call returns only STREAM_HAS_DATA 174 // or STREAM_COMPLETE in |data_available_callback_| call corresponding to 175 // Writer::Close(). 176 TEST_F(StreamTest, ClosedReaderDoesNotReturnStreamEmpty) { 177 TestStreamReader reader; 178 TestStreamWriter writer; 179 180 GURL url("blob://stream"); 181 scoped_refptr<Stream> stream( 182 new Stream(registry_.get(), &writer, url)); 183 EXPECT_TRUE(stream->SetReadObserver(&reader)); 184 185 const int kBufferSize = 0; 186 scoped_refptr<net::IOBuffer> buffer(NewIOBuffer(kBufferSize)); 187 stream->AddData(buffer, kBufferSize); 188 stream->Finalize(); 189 base::MessageLoop::current()->RunUntilIdle(); 190 EXPECT_TRUE(reader.completed()); 191 EXPECT_EQ(0, reader.buffer()->capacity()); 192 } 193 194 TEST_F(StreamTest, GetStream) { 195 TestStreamWriter writer; 196 197 GURL url("blob://stream"); 198 scoped_refptr<Stream> stream1( 199 new Stream(registry_.get(), &writer, url)); 200 201 scoped_refptr<Stream> stream2 = registry_->GetStream(url); 202 ASSERT_EQ(stream1, stream2); 203 } 204 205 TEST_F(StreamTest, GetStream_Missing) { 206 TestStreamWriter writer; 207 208 GURL url1("blob://stream"); 209 scoped_refptr<Stream> stream1( 210 new Stream(registry_.get(), &writer, url1)); 211 212 GURL url2("blob://stream2"); 213 scoped_refptr<Stream> stream2 = registry_->GetStream(url2); 214 ASSERT_FALSE(stream2.get()); 215 } 216 217 TEST_F(StreamTest, CloneStream) { 218 TestStreamWriter writer; 219 220 GURL url1("blob://stream"); 221 scoped_refptr<Stream> stream1( 222 new Stream(registry_.get(), &writer, url1)); 223 224 GURL url2("blob://stream2"); 225 ASSERT_TRUE(registry_->CloneStream(url2, url1)); 226 scoped_refptr<Stream> stream2 = registry_->GetStream(url2); 227 ASSERT_EQ(stream1, stream2); 228 } 229 230 TEST_F(StreamTest, CloneStream_Missing) { 231 TestStreamWriter writer; 232 233 GURL url1("blob://stream"); 234 scoped_refptr<Stream> stream1( 235 new Stream(registry_.get(), &writer, url1)); 236 237 GURL url2("blob://stream2"); 238 GURL url3("blob://stream3"); 239 ASSERT_FALSE(registry_->CloneStream(url2, url3)); 240 scoped_refptr<Stream> stream2 = registry_->GetStream(url2); 241 ASSERT_FALSE(stream2.get()); 242 } 243 244 TEST_F(StreamTest, UnregisterStream) { 245 TestStreamWriter writer; 246 247 GURL url("blob://stream"); 248 scoped_refptr<Stream> stream1( 249 new Stream(registry_.get(), &writer, url)); 250 251 registry_->UnregisterStream(url); 252 scoped_refptr<Stream> stream2 = registry_->GetStream(url); 253 ASSERT_FALSE(stream2.get()); 254 } 255 256 TEST_F(StreamTest, MemoryExceedMemoryUsageLimit) { 257 TestStreamWriter writer1; 258 TestStreamWriter writer2; 259 260 GURL url1("blob://stream"); 261 scoped_refptr<Stream> stream1( 262 new Stream(registry_.get(), &writer1, url1)); 263 264 GURL url2("blob://stream2"); 265 scoped_refptr<Stream> stream2( 266 new Stream(registry_.get(), &writer2, url2)); 267 268 const int kMaxMemoryUsage = 1500000; 269 registry_->set_max_memory_usage_for_testing(kMaxMemoryUsage); 270 271 const int kBufferSize = 1000000; 272 scoped_refptr<net::IOBuffer> buffer(NewIOBuffer(kBufferSize)); 273 writer1.Write(stream1.get(), buffer, kBufferSize); 274 // Make transfer happen. 275 base::MessageLoop::current()->RunUntilIdle(); 276 277 writer2.Write(stream2.get(), buffer, kBufferSize); 278 279 // Written data (1000000 * 2) exceeded limit (1500000). |stream2| should be 280 // unregistered with |registry_|. 281 EXPECT_EQ(NULL, registry_->GetStream(url2).get()); 282 283 writer1.Write(stream1.get(), buffer, kMaxMemoryUsage - kBufferSize); 284 // Should be accepted since stream2 is unregistered and the new data is not 285 // so big to exceed the limit. 286 EXPECT_FALSE(registry_->GetStream(url1).get() == NULL); 287 } 288 289 TEST_F(StreamTest, UnderMemoryUsageLimit) { 290 TestStreamWriter writer; 291 TestStreamReader reader; 292 293 GURL url("blob://stream"); 294 scoped_refptr<Stream> stream(new Stream(registry_.get(), &writer, url)); 295 EXPECT_TRUE(stream->SetReadObserver(&reader)); 296 297 registry_->set_max_memory_usage_for_testing(1500000); 298 299 const int kBufferSize = 1000000; 300 scoped_refptr<net::IOBuffer> buffer(NewIOBuffer(kBufferSize)); 301 writer.Write(stream.get(), buffer, kBufferSize); 302 303 // Run loop to make |reader| consume the data. 304 base::MessageLoop::current()->RunUntilIdle(); 305 306 writer.Write(stream.get(), buffer, kBufferSize); 307 308 EXPECT_EQ(stream.get(), registry_->GetStream(url).get()); 309 } 310 311 } // namespace content 312
