content/renderer/resource_fetcher_browsertest.cc

   1 // Copyright (c) 2012 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/public/renderer/resource_fetcher.h"
   6
   7 #include <stdint.h>
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/command_line.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/time/time.h"
  13 #include "base/timer/timer.h"
  14 #include "content/public/browser/render_view_host.h"
  15 #include "content/public/browser/web_contents.h"
  16 #include "content/public/common/content_switches.h"
  17 #include "content/public/common/url_constants.h"
  18 #include "content/public/renderer/render_view.h"
  19 #include "content/public/test/content_browser_test.h"
  20 #include "content/public/test/content_browser_test_utils.h"
  21 #include "content/public/test/test_utils.h"
  22 #include "content/shell/browser/shell.h"
  23 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  24 #include "third_party/WebKit/public/web/WebFrame.h"
  25 #include "third_party/WebKit/public/web/WebView.h"
  26
  27 using blink::WebFrame;
  28 using blink::WebURLRequest;
  29 using blink::WebURLResponse;
  30
  31 namespace content {
  32
  33 static const int kMaxWaitTimeMs = 5000;
  34
  35 class FetcherDelegate {
  36  public:
  37   FetcherDelegate()
  38       : completed_(false),
  39         timed_out_(false) {
  40     // Start a repeating timer waiting for the download to complete.  The
  41     // callback has to be a static function, so we hold on to our instance.
  42     FetcherDelegate::instance_ = this;
  43     StartTimer();
  44   }
  45
  46   virtual ~FetcherDelegate() {}
  47
  48   ResourceFetcher::Callback NewCallback() {
  49     return base::Bind(&FetcherDelegate::OnURLFetchComplete,
  50                       base::Unretained(this));
  51   }
  52
  53   virtual void OnURLFetchComplete(const WebURLResponse& response,
  54                                   const std::string& data) {
  55     response_ = response;
  56     data_ = data;
  57     completed_ = true;
  58     timer_.Stop();
  59     if (!timed_out_)
  60       quit_task_.Run();
  61   }
  62
  63   bool completed() const { return completed_; }
  64   bool timed_out() const { return timed_out_; }
  65
  66   std::string data() const { return data_; }
  67   const WebURLResponse& response() const { return response_; }
  68
  69   // Wait for the request to complete or timeout.
  70   void WaitForResponse() {
  71     scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
  72     quit_task_ = runner->QuitClosure();
  73     runner->Run();
  74   }
  75
  76   void StartTimer() {
  77     timer_.Start(FROM_HERE,
  78                  base::TimeDelta::FromMilliseconds(kMaxWaitTimeMs),
  79                  this,
  80                  &FetcherDelegate::TimerFired);
  81   }
  82
  83   void TimerFired() {
  84     ASSERT_FALSE(completed_);
  85
  86     timed_out_ = true;
  87     if (!completed_)
  88       quit_task_.Run();
  89     FAIL() << "fetch timed out";
  90   }
  91
  92   static FetcherDelegate* instance_;
  93
  94  private:
  95   base::OneShotTimer<FetcherDelegate> timer_;
  96   bool completed_;
  97   bool timed_out_;
  98   WebURLResponse response_;
  99   std::string data_;
 100   base::Closure quit_task_;
 101 };
 102
 103 FetcherDelegate* FetcherDelegate::instance_ = NULL;
 104
 105 class EvilFetcherDelegate : public FetcherDelegate {
 106  public:
 107   ~EvilFetcherDelegate() override {}
 108
 109   void SetFetcher(ResourceFetcher* fetcher) {
 110     fetcher_.reset(fetcher);
 111   }
 112
 113   void OnURLFetchComplete(const WebURLResponse& response,
 114                           const std::string& data) override {
 115     FetcherDelegate::OnURLFetchComplete(response, data);
 116
 117     // Destroy the ResourceFetcher here.  We are testing that upon returning
 118     // to the ResourceFetcher that it does not crash.  This must be done after
 119     // calling FetcherDelegate::OnURLFetchComplete, since deleting the fetcher
 120     // invalidates |response| and |data|.
 121     fetcher_.reset();
 122   }
 123
 124  private:
 125   scoped_ptr<ResourceFetcher> fetcher_;
 126 };
 127
 128 class ResourceFetcherTests : public ContentBrowserTest {
 129  public:
 130   ResourceFetcherTests() : render_view_routing_id_(MSG_ROUTING_NONE) {}
 131
 132   void SetUpCommandLine(base::CommandLine* command_line) override {
 133     command_line->AppendSwitch(switches::kSingleProcess);
 134 #if defined(OS_WIN)
 135     // Don't want to try to create a GPU process.
 136     command_line->AppendSwitch(switches::kDisableGpu);
 137 #endif
 138   }
 139
 140   void SetUpOnMainThread() override {
 141     render_view_routing_id_ =
 142         shell()->web_contents()->GetRenderViewHost()->GetRoutingID();
 143   }
 144
 145   RenderView* GetRenderView() {
 146     return RenderView::FromRoutingID(render_view_routing_id_);
 147   }
 148
 149   void ResourceFetcherDownloadOnRenderer(const GURL& url) {
 150     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 151
 152     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 153     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 154     fetcher->Start(frame,
 155                    WebURLRequest::RequestContextInternal,
 156                    WebURLRequest::FrameTypeNone,
 157                    ResourceFetcher::PLATFORM_LOADER,
 158                    delegate->NewCallback());
 159
 160     delegate->WaitForResponse();
 161
 162     ASSERT_TRUE(delegate->completed());
 163     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
 164     std::string text = delegate->data();
 165     EXPECT_TRUE(text.find("Basic html test.") != std::string::npos);
 166   }
 167
 168   void ResourceFetcher404OnRenderer(const GURL& url) {
 169     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 170
 171     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 172     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 173     fetcher->Start(frame,
 174                    WebURLRequest::RequestContextInternal,
 175                    WebURLRequest::FrameTypeNone,
 176                    ResourceFetcher::PLATFORM_LOADER,
 177                    delegate->NewCallback());
 178
 179     delegate->WaitForResponse();
 180
 181     ASSERT_TRUE(delegate->completed());
 182     EXPECT_EQ(delegate->response().httpStatusCode(), 404);
 183     EXPECT_TRUE(delegate->data().find("Not Found.") != std::string::npos);
 184   }
 185
 186   void ResourceFetcherDidFailOnRenderer() {
 187     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 188
 189     // Try to fetch a page on a site that doesn't exist.
 190     GURL url("http://localhost:1339/doesnotexist");
 191     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 192     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 193     fetcher->Start(frame,
 194                    WebURLRequest::RequestContextInternal,
 195                    WebURLRequest::FrameTypeNone,
 196                    ResourceFetcher::PLATFORM_LOADER,
 197                    delegate->NewCallback());
 198
 199     delegate->WaitForResponse();
 200
 201     // When we fail, we still call the Delegate callback but we pass in empty
 202     // values.
 203     EXPECT_TRUE(delegate->completed());
 204     EXPECT_TRUE(delegate->response().isNull());
 205     EXPECT_EQ(delegate->data(), std::string());
 206     EXPECT_FALSE(delegate->timed_out());
 207   }
 208
 209   void ResourceFetcherTimeoutOnRenderer(const GURL& url) {
 210     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 211
 212     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 213     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 214     fetcher->Start(frame,
 215                    WebURLRequest::RequestContextInternal,
 216                    WebURLRequest::FrameTypeNone,
 217                    ResourceFetcher::PLATFORM_LOADER,
 218                    delegate->NewCallback());
 219     fetcher->SetTimeout(base::TimeDelta());
 220
 221     delegate->WaitForResponse();
 222
 223     // When we timeout, we still call the Delegate callback but we pass in empty
 224     // values.
 225     EXPECT_TRUE(delegate->completed());
 226     EXPECT_TRUE(delegate->response().isNull());
 227     EXPECT_EQ(delegate->data(), std::string());
 228     EXPECT_FALSE(delegate->timed_out());
 229   }
 230
 231   void ResourceFetcherDeletedInCallbackOnRenderer(const GURL& url) {
 232     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 233
 234     scoped_ptr<EvilFetcherDelegate> delegate(new EvilFetcherDelegate);
 235     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 236     fetcher->Start(frame,
 237                    WebURLRequest::RequestContextInternal,
 238                    WebURLRequest::FrameTypeNone,
 239                    ResourceFetcher::PLATFORM_LOADER,
 240                    delegate->NewCallback());
 241     fetcher->SetTimeout(base::TimeDelta());
 242     delegate->SetFetcher(fetcher.release());
 243
 244     delegate->WaitForResponse();
 245     EXPECT_FALSE(delegate->timed_out());
 246   }
 247
 248   void ResourceFetcherPost(const GURL& url) {
 249     const char* kBody = "Really nifty POST body!";
 250
 251     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 252
 253     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 254     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 255     fetcher->SetMethod("POST");
 256     fetcher->SetBody(kBody);
 257     fetcher->Start(frame,
 258                    WebURLRequest::RequestContextInternal,
 259                    WebURLRequest::FrameTypeNone,
 260                    ResourceFetcher::PLATFORM_LOADER,
 261                    delegate->NewCallback());
 262
 263     delegate->WaitForResponse();
 264     ASSERT_TRUE(delegate->completed());
 265     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
 266     EXPECT_EQ(kBody, delegate->data());
 267   }
 268
 269   void ResourceFetcherSetHeader(const GURL& url) {
 270     const char* kHeader = "Rather boring header.";
 271
 272     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 273
 274     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 275     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
 276     fetcher->SetHeader("header", kHeader);
 277     fetcher->Start(frame,
 278                    WebURLRequest::RequestContextInternal,
 279                    WebURLRequest::FrameTypeNone,
 280                    ResourceFetcher::PLATFORM_LOADER,
 281                    delegate->NewCallback());
 282
 283     delegate->WaitForResponse();
 284     ASSERT_TRUE(delegate->completed());
 285     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
 286     EXPECT_EQ(kHeader, delegate->data());
 287   }
 288
 289   int32 render_view_routing_id_;
 290 };
 291
 292 // Test a fetch from the test server.
 293 // If this flakes, use http://crbug.com/51622.
 294 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherDownload) {
 295   // Need to spin up the renderer.
 296   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 297
 298   ASSERT_TRUE(test_server()->Start());
 299   GURL url(test_server()->GetURL("files/simple_page.html"));
 300
 301   PostTaskToInProcessRendererAndWait(
 302         base::Bind(&ResourceFetcherTests::ResourceFetcherDownloadOnRenderer,
 303                    base::Unretained(this), url));
 304 }
 305
 306 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcher404) {
 307   // Need to spin up the renderer.
 308   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 309
 310   // Test 404 response.
 311   ASSERT_TRUE(test_server()->Start());
 312   GURL url = test_server()->GetURL("files/thisfiledoesntexist.html");
 313
 314   PostTaskToInProcessRendererAndWait(
 315         base::Bind(&ResourceFetcherTests::ResourceFetcher404OnRenderer,
 316                    base::Unretained(this), url));
 317 }
 318
 319 // If this flakes, use http://crbug.com/51622.
 320 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherDidFail) {
 321   // Need to spin up the renderer.
 322   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 323
 324   PostTaskToInProcessRendererAndWait(
 325         base::Bind(&ResourceFetcherTests::ResourceFetcherDidFailOnRenderer,
 326                    base::Unretained(this)));
 327 }
 328
 329 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherTimeout) {
 330   // Need to spin up the renderer.
 331   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 332
 333   // Grab a page that takes at least 1 sec to respond, but set the fetcher to
 334   // timeout in 0 sec.
 335   ASSERT_TRUE(test_server()->Start());
 336   GURL url(test_server()->GetURL("slow?1"));
 337
 338   PostTaskToInProcessRendererAndWait(
 339         base::Bind(&ResourceFetcherTests::ResourceFetcherTimeoutOnRenderer,
 340                    base::Unretained(this), url));
 341 }
 342
 343 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherDeletedInCallback) {
 344   // Need to spin up the renderer.
 345   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 346
 347   // Grab a page that takes at least 1 sec to respond, but set the fetcher to
 348   // timeout in 0 sec.
 349   ASSERT_TRUE(test_server()->Start());
 350   GURL url(test_server()->GetURL("slow?1"));
 351
 352   PostTaskToInProcessRendererAndWait(
 353         base::Bind(
 354             &ResourceFetcherTests::ResourceFetcherDeletedInCallbackOnRenderer,
 355             base::Unretained(this), url));
 356 }
 357
 358
 359
 360 // Test that ResourceFetchers can handle POSTs.
 361 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherPost) {
 362   // Need to spin up the renderer.
 363   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 364
 365   // Grab a page that echos the POST body.
 366   ASSERT_TRUE(test_server()->Start());
 367   GURL url(test_server()->GetURL("echo"));
 368
 369   PostTaskToInProcessRendererAndWait(
 370         base::Bind(
 371             &ResourceFetcherTests::ResourceFetcherPost,
 372             base::Unretained(this), url));
 373 }
 374
 375 // Test that ResourceFetchers can set headers.
 376 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherSetHeader) {
 377   // Need to spin up the renderer.
 378   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
 379
 380   // Grab a page that echos the POST body.
 381   ASSERT_TRUE(test_server()->Start());
 382   GURL url(test_server()->GetURL("echoheader?header"));
 383
 384   PostTaskToInProcessRendererAndWait(
 385         base::Bind(
 386             &ResourceFetcherTests::ResourceFetcherSetHeader,
 387             base::Unretained(this), url));
 388 }
 389
 390 }  // namespace content