| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2015 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 "content/child/shared_memory_received_data_factory.h" |
| 6 |
| 7 #include "content/common/resource_messages.h" |
| 8 #include "ipc/ipc_sender.h" |
| 9 #include "testing/gmock/include/gmock/gmock.h" |
| 10 #include "testing/gtest/include/gtest/gtest.h" |
| 11 |
| 12 namespace content { |
| 13 |
| 14 namespace { |
| 15 |
| 16 using ::testing::_; |
| 17 using ::testing::InSequence; |
| 18 using ::testing::MockFunction; |
| 19 using ::testing::Return; |
| 20 using ::testing::StrictMock; |
| 21 |
| 22 using Checkpoint = StrictMock<MockFunction<void(int)>>; |
| 23 using ReceivedData = RequestPeer::ReceivedData; |
| 24 |
| 25 class MockSender : public IPC::Sender { |
| 26 public: |
| 27 bool Send(IPC::Message* message) override { |
| 28 bool result = false; |
| 29 if (message->type() == ResourceHostMsg_DataReceived_ACK::ID) { |
| 30 Tuple<int> args; |
| 31 ResourceHostMsg_DataReceived_ACK::Read(message, &args); |
| 32 result = SendAck(get<0>(args)); |
| 33 } else { |
| 34 result = SendOtherwise(message); |
| 35 } |
| 36 delete message; |
| 37 return result; |
| 38 } |
| 39 MOCK_METHOD1(SendAck, bool(int)); |
| 40 MOCK_METHOD1(SendOtherwise, bool(IPC::Message*)); |
| 41 }; |
| 42 |
| 43 class SharedMemoryReceivedDataFactoryTest : public ::testing::Test { |
| 44 protected: |
| 45 void SetUp() override { |
| 46 sender_.reset(new StrictMock<MockSender>); |
| 47 request_id_ = 0xdeadbeaf; |
| 48 memory_.reset(new base::SharedMemory), |
| 49 factory_ = make_scoped_refptr(new SharedMemoryReceivedDataFactory( |
| 50 sender_.get(), request_id_, memory_)); |
| 51 ASSERT_TRUE(memory_->CreateAndMapAnonymous(memory_size)); |
| 52 |
| 53 ON_CALL(*sender_, SendAck(_)).WillByDefault(Return(true)); |
| 54 ON_CALL(*sender_, SendOtherwise(_)).WillByDefault(Return(true)); |
| 55 } |
| 56 |
| 57 static const size_t memory_size = 4 * 1024; |
| 58 scoped_ptr<MockSender> sender_; |
| 59 int request_id_; |
| 60 linked_ptr<base::SharedMemory> memory_; |
| 61 scoped_refptr<SharedMemoryReceivedDataFactory> factory_; |
| 62 }; |
| 63 |
| 64 TEST_F(SharedMemoryReceivedDataFactoryTest, Create) { |
| 65 Checkpoint checkpoint; |
| 66 InSequence s; |
| 67 EXPECT_CALL(checkpoint, Call(0)); |
| 68 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 69 EXPECT_CALL(checkpoint, Call(1)); |
| 70 |
| 71 scoped_ptr<ReceivedData> data = factory_->Create(12, 34, 56); |
| 72 const char* memory_start = static_cast<const char*>(memory_->memory()); |
| 73 |
| 74 ASSERT_TRUE(data); |
| 75 EXPECT_EQ(memory_start + 12, data->payload()); |
| 76 EXPECT_EQ(34, data->length()); |
| 77 EXPECT_EQ(56, data->encoded_length()); |
| 78 |
| 79 checkpoint.Call(0); |
| 80 data.reset(); |
| 81 checkpoint.Call(1); |
| 82 } |
| 83 |
| 84 TEST_F(SharedMemoryReceivedDataFactoryTest, CreateMultiple) { |
| 85 Checkpoint checkpoint; |
| 86 InSequence s; |
| 87 EXPECT_CALL(checkpoint, Call(0)); |
| 88 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 89 EXPECT_CALL(checkpoint, Call(1)); |
| 90 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 91 EXPECT_CALL(checkpoint, Call(2)); |
| 92 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 93 EXPECT_CALL(checkpoint, Call(3)); |
| 94 |
| 95 scoped_ptr<ReceivedData> data1 = factory_->Create(0, 1, 1); |
| 96 scoped_ptr<ReceivedData> data2 = factory_->Create(1, 1, 1); |
| 97 scoped_ptr<ReceivedData> data3 = factory_->Create(2, 1, 1); |
| 98 |
| 99 EXPECT_TRUE(data1); |
| 100 EXPECT_TRUE(data2); |
| 101 EXPECT_TRUE(data3); |
| 102 |
| 103 checkpoint.Call(0); |
| 104 data1.reset(); |
| 105 checkpoint.Call(1); |
| 106 data2.reset(); |
| 107 checkpoint.Call(2); |
| 108 data3.reset(); |
| 109 checkpoint.Call(3); |
| 110 } |
| 111 |
| 112 TEST_F(SharedMemoryReceivedDataFactoryTest, ReclaimOutOfOrder) { |
| 113 Checkpoint checkpoint; |
| 114 InSequence s; |
| 115 EXPECT_CALL(checkpoint, Call(0)); |
| 116 EXPECT_CALL(checkpoint, Call(1)); |
| 117 EXPECT_CALL(checkpoint, Call(2)); |
| 118 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 119 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 120 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 121 EXPECT_CALL(checkpoint, Call(3)); |
| 122 |
| 123 scoped_ptr<ReceivedData> data1 = factory_->Create(0, 1, 1); |
| 124 scoped_ptr<ReceivedData> data2 = factory_->Create(1, 1, 1); |
| 125 scoped_ptr<ReceivedData> data3 = factory_->Create(2, 1, 1); |
| 126 |
| 127 EXPECT_TRUE(data1); |
| 128 EXPECT_TRUE(data2); |
| 129 EXPECT_TRUE(data3); |
| 130 |
| 131 checkpoint.Call(0); |
| 132 data3.reset(); |
| 133 checkpoint.Call(1); |
| 134 data2.reset(); |
| 135 checkpoint.Call(2); |
| 136 data1.reset(); |
| 137 checkpoint.Call(3); |
| 138 } |
| 139 |
| 140 TEST_F(SharedMemoryReceivedDataFactoryTest, ReclaimOutOfOrderPartially) { |
| 141 Checkpoint checkpoint; |
| 142 InSequence s; |
| 143 EXPECT_CALL(checkpoint, Call(0)); |
| 144 EXPECT_CALL(checkpoint, Call(1)); |
| 145 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 146 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 147 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 148 EXPECT_CALL(checkpoint, Call(2)); |
| 149 EXPECT_CALL(checkpoint, Call(3)); |
| 150 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 151 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 152 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 153 EXPECT_CALL(checkpoint, Call(4)); |
| 154 |
| 155 scoped_ptr<ReceivedData> data1 = factory_->Create(0, 1, 1); |
| 156 scoped_ptr<ReceivedData> data2 = factory_->Create(1, 1, 1); |
| 157 scoped_ptr<ReceivedData> data3 = factory_->Create(2, 1, 1); |
| 158 scoped_ptr<ReceivedData> data4 = factory_->Create(3, 1, 1); |
| 159 scoped_ptr<ReceivedData> data5 = factory_->Create(4, 1, 1); |
| 160 scoped_ptr<ReceivedData> data6 = factory_->Create(5, 1, 1); |
| 161 |
| 162 EXPECT_TRUE(data1); |
| 163 EXPECT_TRUE(data2); |
| 164 EXPECT_TRUE(data3); |
| 165 EXPECT_TRUE(data4); |
| 166 EXPECT_TRUE(data5); |
| 167 EXPECT_TRUE(data6); |
| 168 |
| 169 checkpoint.Call(0); |
| 170 data3.reset(); |
| 171 data6.reset(); |
| 172 data2.reset(); |
| 173 checkpoint.Call(1); |
| 174 data1.reset(); |
| 175 checkpoint.Call(2); |
| 176 data5.reset(); |
| 177 checkpoint.Call(3); |
| 178 data4.reset(); |
| 179 checkpoint.Call(4); |
| 180 } |
| 181 |
| 182 TEST_F(SharedMemoryReceivedDataFactoryTest, Stop) { |
| 183 Checkpoint checkpoint; |
| 184 InSequence s; |
| 185 EXPECT_CALL(checkpoint, Call(0)); |
| 186 EXPECT_CALL(checkpoint, Call(1)); |
| 187 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 188 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 189 EXPECT_CALL(*sender_, SendAck(request_id_)); |
| 190 EXPECT_CALL(checkpoint, Call(2)); |
| 191 EXPECT_CALL(checkpoint, Call(3)); |
| 192 |
| 193 scoped_ptr<ReceivedData> data1 = factory_->Create(0, 1, 1); |
| 194 scoped_ptr<ReceivedData> data2 = factory_->Create(1, 1, 1); |
| 195 scoped_ptr<ReceivedData> data3 = factory_->Create(2, 1, 1); |
| 196 scoped_ptr<ReceivedData> data4 = factory_->Create(3, 1, 1); |
| 197 scoped_ptr<ReceivedData> data5 = factory_->Create(4, 1, 1); |
| 198 scoped_ptr<ReceivedData> data6 = factory_->Create(5, 1, 1); |
| 199 |
| 200 EXPECT_TRUE(data1); |
| 201 EXPECT_TRUE(data2); |
| 202 EXPECT_TRUE(data3); |
| 203 EXPECT_TRUE(data4); |
| 204 EXPECT_TRUE(data5); |
| 205 EXPECT_TRUE(data6); |
| 206 |
| 207 checkpoint.Call(0); |
| 208 data3.reset(); |
| 209 data6.reset(); |
| 210 data2.reset(); |
| 211 checkpoint.Call(1); |
| 212 data1.reset(); |
| 213 checkpoint.Call(2); |
| 214 factory_->Stop(); |
| 215 data5.reset(); |
| 216 data4.reset(); |
| 217 checkpoint.Call(3); |
| 218 } |
| 219 |
| 220 } // namespace |
| 221 |
| 222 } // namespace content |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1103813002:
Make WebURLLoader capable of retaining received buffers. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master