content/common/resource_dispatcher_unittest.cc

   1 // Copyright (c) 2011 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 <string>
   6 #include <vector>
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop.h"
  10 #include "base/process.h"
  11 #include "base/process_util.h"
  12 #include "content/common/resource_dispatcher.h"
  13 #include "content/common/resource_messages.h"
  14 #include "content/common/resource_response.h"
  15 #include "net/base/upload_data.h"
  16 #include "net/http/http_response_headers.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "webkit/appcache/appcache_interfaces.h"
  19
  20 using webkit_glue::ResourceLoaderBridge;
  21 using webkit_glue::ResourceResponseInfo;
  22
  23 static const char test_page_url[] = "http://www.google.com/";
  24 static const char test_page_headers[] =
  25   "HTTP/1.1 200 OK\nContent-Type:text/html\n\n";
  26 static const char test_page_mime_type[] = "text/html";
  27 static const char test_page_charset[] = "";
  28 static const char test_page_contents[] =
  29   "<html><head><title>Google</title></head><body><h1>Google</h1></body></html>";
  30 static const uint32 test_page_contents_len = arraysize(test_page_contents) - 1;
  31
  32 static const char kShmemSegmentName[] = "DeferredResourceLoaderTest";
  33
  34 // Listens for request response data and stores it so that it can be compared
  35 // to the reference data.
  36 class TestRequestCallback : public ResourceLoaderBridge::Peer {
  37  public:
  38   TestRequestCallback() : complete_(false) {
  39   }
  40
  41   virtual void OnUploadProgress(uint64 position, uint64 size) {
  42   }
  43
  44   virtual bool OnReceivedRedirect(
  45       const GURL& new_url,
  46       const ResourceResponseInfo& info,
  47       bool* has_new_first_party_for_cookies,
  48       GURL* new_first_party_for_cookies) {
  49     *has_new_first_party_for_cookies = false;
  50     return true;
  51   }
  52
  53   virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
  54   }
  55
  56   virtual void OnDownloadedData(int len) {
  57   }
  58
  59   virtual void OnReceivedData(const char* data,
  60                               int data_length,
  61                               int encoded_data_length) {
  62     EXPECT_FALSE(complete_);
  63     data_.append(data, data_length);
  64     total_encoded_data_length_ += encoded_data_length;
  65   }
  66
  67   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
  68                                   const std::string& security_info,
  69                                   const base::Time& completion_time) {
  70     EXPECT_FALSE(complete_);
  71     complete_ = true;
  72   }
  73
  74   bool complete() const {
  75     return complete_;
  76   }
  77   const std::string& data() const {
  78     return data_;
  79   }
  80   int total_encoded_data_length() const {
  81     return total_encoded_data_length_;
  82   }
  83
  84  private:
  85   bool complete_;
  86   std::string data_;
  87   int total_encoded_data_length_;
  88 };
  89
  90
  91 // Sets up the message sender override for the unit test
  92 class ResourceDispatcherTest : public testing::Test,
  93                                public IPC::Message::Sender {
  94  public:
  95   // Emulates IPC send operations (IPC::Message::Sender) by adding
  96   // pending messages to the queue.
  97   virtual bool Send(IPC::Message* msg) {
  98     message_queue_.push_back(IPC::Message(*msg));
  99     delete msg;
 100     return true;
 101   }
 102
 103   // Emulates the browser process and processes the pending IPC messages,
 104   // returning the hardcoded file contents.
 105   void ProcessMessages() {
 106     while (!message_queue_.empty()) {
 107       int request_id;
 108       ResourceHostMsg_Request request;
 109       ASSERT_TRUE(ResourceHostMsg_RequestResource::Read(
 110           &message_queue_[0], &request_id, &request));
 111
 112       // check values
 113       EXPECT_EQ(test_page_url, request.url.spec());
 114
 115       // received response message
 116       ResourceResponseHead response;
 117       std::string raw_headers(test_page_headers);
 118       std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
 119       response.headers = new net::HttpResponseHeaders(raw_headers);
 120       response.mime_type = test_page_mime_type;
 121       response.charset = test_page_charset;
 122       dispatcher_->OnReceivedResponse(request_id, response);
 123
 124       // received data message with the test contents
 125       base::SharedMemory shared_mem;
 126       EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len));
 127       char* put_data_here = static_cast<char*>(shared_mem.memory());
 128       memcpy(put_data_here, test_page_contents, test_page_contents_len);
 129       base::SharedMemoryHandle dup_handle;
 130       EXPECT_TRUE(shared_mem.GiveToProcess(
 131           base::Process::Current().handle(), &dup_handle));
 132       dispatcher_->OnReceivedData(
 133           message_queue_[0],
 134           request_id,
 135           dup_handle,
 136           test_page_contents_len,
 137           test_page_contents_len);
 138
 139       message_queue_.erase(message_queue_.begin());
 140
 141       // read the ack message.
 142       Tuple1<int> request_ack;
 143       ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
 144           &message_queue_[0], &request_ack));
 145
 146       ASSERT_EQ(request_ack.a, request_id);
 147
 148       message_queue_.erase(message_queue_.begin());
 149     }
 150   }
 151
 152  protected:
 153   // testing::Test
 154   virtual void SetUp() {
 155     dispatcher_.reset(new ResourceDispatcher(this));
 156   }
 157   virtual void TearDown() {
 158     dispatcher_.reset();
 159   }
 160
 161   ResourceLoaderBridge* CreateBridge() {
 162     webkit_glue::ResourceLoaderBridge::RequestInfo request_info;
 163     request_info.method = "GET";
 164     request_info.url = GURL(test_page_url);
 165     request_info.first_party_for_cookies = GURL(test_page_url);
 166     request_info.referrer = GURL();
 167     request_info.headers = std::string();
 168     request_info.load_flags = 0;
 169     request_info.requestor_pid = 0;
 170     request_info.request_type = ResourceType::SUB_RESOURCE;
 171     request_info.appcache_host_id = appcache::kNoHostId;
 172     request_info.routing_id = 0;
 173
 174     return dispatcher_->CreateBridge(request_info);
 175   }
 176
 177   std::vector<IPC::Message> message_queue_;
 178   static scoped_ptr<ResourceDispatcher> dispatcher_;
 179 };
 180
 181 /*static*/
 182 scoped_ptr<ResourceDispatcher> ResourceDispatcherTest::dispatcher_;
 183
 184 // Does a simple request and tests that the correct data is received.
 185 TEST_F(ResourceDispatcherTest, RoundTrip) {
 186   TestRequestCallback callback;
 187   ResourceLoaderBridge* bridge = CreateBridge();
 188
 189   bridge->Start(&callback);
 190
 191   ProcessMessages();
 192
 193   // FIXME(brettw) when the request complete messages are actually handledo
 194   // and dispatched, uncomment this.
 195   //EXPECT_TRUE(callback.complete());
 196   //EXPECT_STREQ(test_page_contents, callback.data().c_str());
 197   //EXPECT_EQ(test_page_contents_len, callback.total_encoded_data_length());
 198
 199   delete bridge;
 200 }
 201
 202 // Tests that the request IDs are straight when there are multiple requests.
 203 TEST_F(ResourceDispatcherTest, MultipleRequests) {
 204   // FIXME
 205 }
 206
 207 // Tests that the cancel method prevents other messages from being received
 208 TEST_F(ResourceDispatcherTest, Cancel) {
 209   // FIXME
 210 }
 211
 212 TEST_F(ResourceDispatcherTest, Cookies) {
 213   // FIXME
 214 }
 215
 216 TEST_F(ResourceDispatcherTest, SerializedPostData) {
 217   // FIXME
 218 }
 219
 220 // This class provides functionality to validate whether the ResourceDispatcher
 221 // object honors the deferred loading contract correctly, i.e. if deferred
 222 // loading is enabled it should queue up any responses received. If deferred
 223 // loading is enabled/disabled in the context of a dispatched message, other
 224 // queued messages should not be dispatched until deferred load is turned off.
 225 class DeferredResourceLoadingTest : public ResourceDispatcherTest,
 226                                     public ResourceLoaderBridge::Peer {
 227  public:
 228   DeferredResourceLoadingTest()
 229       : defer_loading_(false) {
 230   }
 231
 232   virtual bool Send(IPC::Message* msg) {
 233     delete msg;
 234     return true;
 235   }
 236
 237   void InitMessages() {
 238     set_defer_loading(true);
 239
 240     ResourceResponseHead response_head;
 241     response_head.status.set_status(net::URLRequestStatus::SUCCESS);
 242
 243     IPC::Message* response_message =
 244         new ResourceMsg_ReceivedResponse(0, 0, response_head);
 245
 246     dispatcher_->OnMessageReceived(*response_message);
 247
 248     delete response_message;
 249
 250     // Duplicate the shared memory handle so both the test and the callee can
 251     // close their copy.
 252     base::SharedMemoryHandle duplicated_handle;
 253     EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
 254                                               &duplicated_handle));
 255
 256     response_message =
 257         new ResourceMsg_DataReceived(0, 0, duplicated_handle, 100, 100);
 258
 259     dispatcher_->OnMessageReceived(*response_message);
 260
 261     delete response_message;
 262
 263     set_defer_loading(false);
 264   }
 265
 266   // ResourceLoaderBridge::Peer methods.
 267   virtual void OnUploadProgress(uint64 position, uint64 size) {
 268   }
 269
 270   virtual bool OnReceivedRedirect(
 271       const GURL& new_url,
 272       const ResourceResponseInfo& info,
 273       bool* has_new_first_party_for_cookies,
 274       GURL* new_first_party_for_cookies) {
 275     *has_new_first_party_for_cookies = false;
 276     return true;
 277   }
 278
 279   virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
 280     EXPECT_EQ(defer_loading_, false);
 281     set_defer_loading(true);
 282   }
 283
 284   virtual void OnDownloadedData(int len) {
 285   }
 286
 287   virtual void OnReceivedData(const char* data,
 288                               int data_length,
 289                               int encoded_data_length) {
 290     EXPECT_EQ(defer_loading_, false);
 291     set_defer_loading(false);
 292   }
 293
 294   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
 295                                   const std::string& security_info,
 296                                   const base::Time& completion_time) {
 297   }
 298
 299  protected:
 300   virtual void SetUp() {
 301     ResourceDispatcherTest::SetUp();
 302     shared_handle_.Delete(kShmemSegmentName);
 303     EXPECT_TRUE(shared_handle_.CreateNamed(kShmemSegmentName, false, 100));
 304   }
 305
 306   virtual void TearDown() {
 307     shared_handle_.Close();
 308     EXPECT_TRUE(shared_handle_.Delete(kShmemSegmentName));
 309     ResourceDispatcherTest::TearDown();
 310   }
 311
 312  private:
 313   void set_defer_loading(bool defer) {
 314     defer_loading_ = defer;
 315     dispatcher_->SetDefersLoading(0, defer);
 316   }
 317
 318   bool defer_loading() const {
 319     return defer_loading_;
 320   }
 321
 322   bool defer_loading_;
 323   base::SharedMemory shared_handle_;
 324 };
 325
 326 TEST_F(DeferredResourceLoadingTest, DeferredLoadTest) {
 327   MessageLoop message_loop(MessageLoop::TYPE_IO);
 328
 329   ResourceLoaderBridge* bridge = CreateBridge();
 330
 331   bridge->Start(this);
 332   InitMessages();
 333
 334   // Dispatch deferred messages.
 335   message_loop.RunAllPending();
 336   delete bridge;
 337 }