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 "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/command_line.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/time/time.h"
  12 #include "base/timer/timer.h"
  13 #include "content/public/common/content_switches.h"
  14 #include "content/public/common/url_constants.h"
  15 #include "content/public/renderer/render_view.h"
  16 #include "content/public/test/test_utils.h"
  17 #include "content/shell/browser/shell.h"
  18 #include "content/test/content_browser_test.h"
  19 #include "content/test/content_browser_test_utils.h"
  20 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  21 #include "third_party/WebKit/public/web/WebFrame.h"
  22 #include "third_party/WebKit/public/web/WebView.h"
  23
  24 using blink::WebFrame;
  25 using blink::WebURLRequest;
  26 using blink::WebURLResponse;
  27
  28 namespace content {
  29
  30 static const int kMaxWaitTimeMs = 5000;
  31
  32 class FetcherDelegate {
  33  public:
  34   FetcherDelegate()
  35       : completed_(false),
  36         timed_out_(false) {
  37     // Start a repeating timer waiting for the download to complete.  The
  38     // callback has to be a static function, so we hold on to our instance.
  39     FetcherDelegate::instance_ = this;
  40     StartTimer();
  41   }
  42
  43   virtual ~FetcherDelegate() {}
  44
  45   ResourceFetcher::Callback NewCallback() {
  46     return base::Bind(&FetcherDelegate::OnURLFetchComplete,
  47                       base::Unretained(this));
  48   }
  49
  50   virtual void OnURLFetchComplete(const WebURLResponse& response,
  51                                   const std::string& data) {
  52     response_ = response;
  53     data_ = data;
  54     completed_ = true;
  55     timer_.Stop();
  56     if (!timed_out_)
  57       quit_task_.Run();
  58   }
  59
  60   bool completed() const { return completed_; }
  61   bool timed_out() const { return timed_out_; }
  62
  63   std::string data() const { return data_; }
  64   const WebURLResponse& response() const { return response_; }
  65
  66   // Wait for the request to complete or timeout.
  67   void WaitForResponse() {
  68     scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
  69     quit_task_ = runner->QuitClosure();
  70     runner->Run();
  71   }
  72
  73   void StartTimer() {
  74     timer_.Start(FROM_HERE,
  75                  base::TimeDelta::FromMilliseconds(kMaxWaitTimeMs),
  76                  this,
  77                  &FetcherDelegate::TimerFired);
  78   }
  79
  80   void TimerFired() {
  81     ASSERT_FALSE(completed_);
  82
  83     timed_out_ = true;
  84     if (!completed_)
  85       quit_task_.Run();
  86     FAIL() << "fetch timed out";
  87   }
  88
  89   static FetcherDelegate* instance_;
  90
  91  private:
  92   base::OneShotTimer<FetcherDelegate> timer_;
  93   bool completed_;
  94   bool timed_out_;
  95   WebURLResponse response_;
  96   std::string data_;
  97   base::Closure quit_task_;
  98 };
  99
 100 FetcherDelegate* FetcherDelegate::instance_ = NULL;
 101
 102 class EvilFetcherDelegate : public FetcherDelegate {
 103  public:
 104   virtual ~EvilFetcherDelegate() {}
 105
 106   void SetFetcher(ResourceFetcher* fetcher) {
 107     fetcher_.reset(fetcher);
 108   }
 109
 110   virtual void OnURLFetchComplete(const WebURLResponse& response,
 111                                   const std::string& data) OVERRIDE {
 112     FetcherDelegate::OnURLFetchComplete(response, data);
 113
 114     // Destroy the ResourceFetcher here.  We are testing that upon returning
 115     // to the ResourceFetcher that it does not crash.  This must be done after
 116     // calling FetcherDelegate::OnURLFetchComplete, since deleting the fetcher
 117     // invalidates |response| and |data|.
 118     fetcher_.reset();
 119   }
 120
 121  private:
 122   scoped_ptr<ResourceFetcher> fetcher_;
 123 };
 124
 125 class ResourceFetcherTests : public ContentBrowserTest {
 126  public:
 127   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 128     command_line->AppendSwitch(switches::kSingleProcess);
 129 #if defined(OS_WIN) && defined(USE_AURA)
 130     // Don't want to try to create a GPU process.
 131     command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
 132 #endif
 133   }
 134
 135   RenderView* GetRenderView() {
 136     // We could have the test on the UI thread get the WebContent's routing ID,
 137     // but we know this will be the first RV so skip that and just hardcode it.
 138     return RenderView::FromRoutingID(1);
 139   }
 140
 141   void ResourceFetcherDownloadOnRenderer(const GURL& url) {
 142     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 143
 144     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 145     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(
 146         url, frame, WebURLRequest::TargetIsMainFrame, delegate->NewCallback()));
 147
 148     delegate->WaitForResponse();
 149
 150     ASSERT_TRUE(delegate->completed());
 151     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
 152     std::string text = delegate->data();
 153     EXPECT_TRUE(text.find("Basic html test.") != std::string::npos);
 154   }
 155
 156   void ResourceFetcher404OnRenderer(const GURL& url) {
 157     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 158
 159     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 160     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(
 161         url, frame, WebURLRequest::TargetIsMainFrame, delegate->NewCallback()));
 162
 163     delegate->WaitForResponse();
 164
 165     ASSERT_TRUE(delegate->completed());
 166     EXPECT_EQ(delegate->response().httpStatusCode(), 404);
 167     EXPECT_TRUE(delegate->data().find("Not Found.") != std::string::npos);
 168   }
 169
 170   void ResourceFetcherDidFailOnRenderer() {
 171     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 172
 173     // Try to fetch a page on a site that doesn't exist.
 174     GURL url("http://localhost:1339/doesnotexist");
 175     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 176     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(
 177         url, frame, WebURLRequest::TargetIsMainFrame, delegate->NewCallback()));
 178
 179     delegate->WaitForResponse();
 180
 181     // When we fail, we still call the Delegate callback but we pass in empty
 182     // values.
 183     EXPECT_TRUE(delegate->completed());
 184     EXPECT_TRUE(delegate->response().isNull());
 185     EXPECT_EQ(delegate->data(), std::string());
 186     EXPECT_FALSE(delegate->timed_out());
 187   }
 188
 189   void ResourceFetcherTimeoutOnRenderer(const GURL& url) {
 190     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 191
 192     scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
 193     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(
 194         url, frame, WebURLRequest::TargetIsMainFrame,
 195         delegate->NewCallback()));
 196     fetcher->SetTimeout(base::TimeDelta());
 197
 198     delegate->WaitForResponse();
 199
 200     // When we timeout, we still call the Delegate callback but we pass in empty
 201     // values.
 202     EXPECT_TRUE(delegate->completed());
 203     EXPECT_TRUE(delegate->response().isNull());
 204     EXPECT_EQ(delegate->data(), std::string());
 205     EXPECT_FALSE(delegate->timed_out());
 206   }
 207
 208   void ResourceFetcherDeletedInCallbackOnRenderer(const GURL& url) {
 209     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 210
 211     scoped_ptr<EvilFetcherDelegate> delegate(new EvilFetcherDelegate);
 212     scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(
 213         url, frame, WebURLRequest::TargetIsMainFrame,
 214         delegate->NewCallback()));
 215     fetcher->SetTimeout(base::TimeDelta());
 216     delegate->SetFetcher(fetcher.release());
 217
 218     delegate->WaitForResponse();
 219     EXPECT_FALSE(delegate->timed_out());
 220   }
 221 };
 222
 223 // Test a fetch from the test server.
 224 // If this flakes, use http://crbug.com/51622.
 225 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherDownload) {
 226   // Need to spin up the renderer.
 227   NavigateToURL(shell(), GURL(kAboutBlankURL));
 228
 229   ASSERT_TRUE(test_server()->Start());
 230   GURL url(test_server()->GetURL("files/simple_page.html"));
 231
 232   PostTaskToInProcessRendererAndWait(
 233         base::Bind(&ResourceFetcherTests::ResourceFetcherDownloadOnRenderer,
 234                    base::Unretained(this), url));
 235 }
 236
 237 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcher404) {
 238   // Need to spin up the renderer.
 239   NavigateToURL(shell(), GURL(kAboutBlankURL));
 240
 241   // Test 404 response.
 242   ASSERT_TRUE(test_server()->Start());
 243   GURL url = test_server()->GetURL("files/thisfiledoesntexist.html");
 244
 245   PostTaskToInProcessRendererAndWait(
 246         base::Bind(&ResourceFetcherTests::ResourceFetcher404OnRenderer,
 247                    base::Unretained(this), url));
 248 }
 249
 250 // If this flakes, use http://crbug.com/51622.
 251 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherDidFail) {
 252   // Need to spin up the renderer.
 253   NavigateToURL(shell(), GURL(kAboutBlankURL));
 254
 255   PostTaskToInProcessRendererAndWait(
 256         base::Bind(&ResourceFetcherTests::ResourceFetcherDidFailOnRenderer,
 257                    base::Unretained(this)));
 258 }
 259
 260 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherTimeout) {
 261   // Need to spin up the renderer.
 262   NavigateToURL(shell(), GURL(kAboutBlankURL));
 263
 264   // Grab a page that takes at least 1 sec to respond, but set the fetcher to
 265   // timeout in 0 sec.
 266   ASSERT_TRUE(test_server()->Start());
 267   GURL url(test_server()->GetURL("slow?1"));
 268
 269   PostTaskToInProcessRendererAndWait(
 270         base::Bind(&ResourceFetcherTests::ResourceFetcherTimeoutOnRenderer,
 271                    base::Unretained(this), url));
 272 }
 273
 274 IN_PROC_BROWSER_TEST_F(ResourceFetcherTests, ResourceFetcherDeletedInCallback) {
 275   // Need to spin up the renderer.
 276   NavigateToURL(shell(), GURL(kAboutBlankURL));
 277
 278   // Grab a page that takes at least 1 sec to respond, but set the fetcher to
 279   // timeout in 0 sec.
 280   ASSERT_TRUE(test_server()->Start());
 281   GURL url(test_server()->GetURL("slow?1"));
 282
 283   PostTaskToInProcessRendererAndWait(
 284         base::Bind(
 285             &ResourceFetcherTests::ResourceFetcherDeletedInCallbackOnRenderer,
 286             base::Unretained(this), url));
 287 }
 288
 289 }  // namespace content