components/navigation_interception/intercept_navigation_resource_throttle_unittest.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 "base/bind.h"
   6 #include "base/bind_helpers.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/run_loop.h"
   9 #include "base/synchronization/waitable_event.h"
  10 #include "components/navigation_interception/intercept_navigation_resource_throttle.h"
  11 #include "components/navigation_interception/navigation_params.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "content/public/browser/render_frame_host.h"
  14 #include "content/public/browser/render_process_host.h"
  15 #include "content/public/browser/resource_context.h"
  16 #include "content/public/browser/resource_controller.h"
  17 #include "content/public/browser/resource_dispatcher_host.h"
  18 #include "content/public/browser/resource_dispatcher_host_delegate.h"
  19 #include "content/public/browser/resource_request_info.h"
  20 #include "content/public/browser/resource_throttle.h"
  21 #include "content/public/browser/web_contents.h"
  22 #include "content/public/browser/web_contents_delegate.h"
  23 #include "content/public/common/page_transition_types.h"
  24 #include "content/public/test/mock_resource_context.h"
  25 #include "content/public/test/test_renderer_host.h"
  26 #include "net/base/request_priority.h"
  27 #include "net/http/http_response_headers.h"
  28 #include "net/http/http_response_info.h"
  29 #include "net/url_request/url_request.h"
  30 #include "net/url_request/url_request_test_util.h"
  31 #include "testing/gmock/include/gmock/gmock.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 using testing::_;
  35 using testing::Eq;
  36 using testing::Ne;
  37 using testing::Property;
  38 using testing::Return;
  39
  40 namespace navigation_interception {
  41
  42 namespace {
  43
  44 const char kTestUrl[] = "http://www.test.com/";
  45 const char kUnsafeTestUrl[] = "about:crash";
  46
  47 // The MS C++ compiler complains about not being able to resolve which url()
  48 // method (const or non-const) to use if we use the Property matcher to check
  49 // the return value of the NavigationParams::url() method.
  50 // It is possible to suppress the error by specifying the types directly but
  51 // that results in very ugly syntax, which is why these custom matchers are
  52 // used instead.
  53 MATCHER(NavigationParamsUrlIsTest, "") {
  54   return arg.url() == GURL(kTestUrl);
  55 }
  56
  57 MATCHER(NavigationParamsUrlIsSafe, "") {
  58   return arg.url() != GURL(kUnsafeTestUrl);
  59 }
  60
  61 }  // namespace
  62
  63
  64 // MockInterceptCallbackReceiver ----------------------------------------------
  65
  66 class MockInterceptCallbackReceiver {
  67  public:
  68   MOCK_METHOD2(ShouldIgnoreNavigation,
  69                bool(content::WebContents* source,
  70                     const NavigationParams& navigation_params));
  71 };
  72
  73 // MockResourceController -----------------------------------------------------
  74 class MockResourceController : public content::ResourceController {
  75  public:
  76   enum Status {
  77     UNKNOWN,
  78     RESUMED,
  79     CANCELLED
  80   };
  81
  82   MockResourceController()
  83       : status_(UNKNOWN) {
  84   }
  85
  86   Status status() const { return status_; }
  87
  88   // ResourceController:
  89   virtual void Cancel() OVERRIDE {
  90     NOTREACHED();
  91   }
  92   virtual void CancelAndIgnore() OVERRIDE {
  93     status_ = CANCELLED;
  94   }
  95   virtual void CancelWithError(int error_code) OVERRIDE {
  96     NOTREACHED();
  97   }
  98   virtual void Resume() OVERRIDE {
  99     DCHECK(status_ == UNKNOWN);
 100     status_ = RESUMED;
 101   }
 102
 103  private:
 104   Status status_;
 105 };
 106
 107 // TestIOThreadState ----------------------------------------------------------
 108
 109 enum RedirectMode {
 110   REDIRECT_MODE_NO_REDIRECT,
 111   REDIRECT_MODE_302,
 112 };
 113
 114 class TestIOThreadState {
 115  public:
 116   TestIOThreadState(const GURL& url,
 117                     int render_process_id,
 118                     int render_frame_id,
 119                     const std::string& request_method,
 120                     RedirectMode redirect_mode,
 121                     MockInterceptCallbackReceiver* callback_receiver)
 122       : resource_context_(&test_url_request_context_),
 123         request_(url,
 124                  net::DEFAULT_PRIORITY,
 125                  NULL,
 126                  resource_context_.GetRequestContext()) {
 127     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 128     if (render_process_id != MSG_ROUTING_NONE &&
 129         render_frame_id != MSG_ROUTING_NONE) {
 130       content::ResourceRequestInfo::AllocateForTesting(
 131           &request_,
 132           ResourceType::MAIN_FRAME,
 133           &resource_context_,
 134           render_process_id,
 135           MSG_ROUTING_NONE,
 136           render_frame_id,
 137           false);
 138     }
 139     throttle_.reset(new InterceptNavigationResourceThrottle(
 140         &request_,
 141         base::Bind(&MockInterceptCallbackReceiver::ShouldIgnoreNavigation,
 142                    base::Unretained(callback_receiver))));
 143     throttle_->set_controller_for_testing(&throttle_controller_);
 144     request_.set_method(request_method);
 145
 146     if (redirect_mode == REDIRECT_MODE_302) {
 147       net::HttpResponseInfo& response_info =
 148           const_cast<net::HttpResponseInfo&>(request_.response_info());
 149       response_info.headers = new net::HttpResponseHeaders(
 150           "Status: 302 Found\0\0");
 151     }
 152   }
 153
 154   void ThrottleWillStartRequest(bool* defer) {
 155     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 156     throttle_->WillStartRequest(defer);
 157   }
 158
 159   void ThrottleWillRedirectRequest(const GURL& new_url, bool* defer) {
 160     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 161     throttle_->WillRedirectRequest(new_url, defer);
 162   }
 163
 164   bool request_resumed() const {
 165     return throttle_controller_.status() ==
 166         MockResourceController::RESUMED;
 167   }
 168
 169   bool request_cancelled() const {
 170     return throttle_controller_.status() ==
 171         MockResourceController::CANCELLED;
 172   }
 173
 174  private:
 175   net::TestURLRequestContext test_url_request_context_;
 176   content::MockResourceContext resource_context_;
 177   net::URLRequest request_;
 178   scoped_ptr<InterceptNavigationResourceThrottle> throttle_;
 179   MockResourceController throttle_controller_;
 180 };
 181
 182 // InterceptNavigationResourceThrottleTest ------------------------------------
 183
 184 class InterceptNavigationResourceThrottleTest
 185   : public content::RenderViewHostTestHarness {
 186  public:
 187   InterceptNavigationResourceThrottleTest()
 188       : mock_callback_receiver_(new MockInterceptCallbackReceiver()),
 189         io_thread_state_(NULL) {
 190   }
 191
 192   virtual void SetUp() OVERRIDE {
 193     RenderViewHostTestHarness::SetUp();
 194   }
 195
 196   virtual void TearDown() OVERRIDE {
 197     if (web_contents())
 198       web_contents()->SetDelegate(NULL);
 199
 200     content::BrowserThread::DeleteSoon(
 201         content::BrowserThread::IO, FROM_HERE, io_thread_state_);
 202
 203     RenderViewHostTestHarness::TearDown();
 204   }
 205
 206   void SetIOThreadState(TestIOThreadState* io_thread_state) {
 207     io_thread_state_ = io_thread_state;
 208   }
 209
 210   void RunThrottleWillStartRequestOnIOThread(
 211       const GURL& url,
 212       const std::string& request_method,
 213       RedirectMode redirect_mode,
 214       int render_process_id,
 215       int render_frame_id,
 216       bool* defer) {
 217     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 218     TestIOThreadState* io_thread_state =
 219         new TestIOThreadState(url, render_process_id, render_frame_id,
 220                               request_method, redirect_mode,
 221                               mock_callback_receiver_.get());
 222
 223     SetIOThreadState(io_thread_state);
 224
 225     if (redirect_mode == REDIRECT_MODE_NO_REDIRECT)
 226       io_thread_state->ThrottleWillStartRequest(defer);
 227     else
 228       io_thread_state->ThrottleWillRedirectRequest(url, defer);
 229   }
 230
 231  protected:
 232   enum ShouldIgnoreNavigationCallbackAction {
 233     IgnoreNavigation,
 234     DontIgnoreNavigation
 235   };
 236
 237   void SetUpWebContentsDelegateAndDrainRunLoop(
 238       ShouldIgnoreNavigationCallbackAction callback_action,
 239       bool* defer) {
 240     ON_CALL(*mock_callback_receiver_, ShouldIgnoreNavigation(_, _))
 241       .WillByDefault(Return(callback_action == IgnoreNavigation));
 242     EXPECT_CALL(*mock_callback_receiver_,
 243                 ShouldIgnoreNavigation(web_contents(),
 244                                        NavigationParamsUrlIsTest()))
 245       .Times(1);
 246
 247     content::BrowserThread::PostTask(
 248         content::BrowserThread::IO,
 249         FROM_HERE,
 250         base::Bind(
 251             &InterceptNavigationResourceThrottleTest::
 252                 RunThrottleWillStartRequestOnIOThread,
 253             base::Unretained(this),
 254             GURL(kTestUrl),
 255             "GET",
 256             REDIRECT_MODE_NO_REDIRECT,
 257             web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
 258             web_contents()->GetMainFrame()->GetRoutingID(),
 259             base::Unretained(defer)));
 260
 261     // Wait for the request to finish processing.
 262     base::RunLoop().RunUntilIdle();
 263   }
 264
 265   void WaitForPreviouslyScheduledIoThreadWork() {
 266     base::WaitableEvent io_thread_work_done(true, false);
 267     content::BrowserThread::PostTask(
 268         content::BrowserThread::IO,
 269         FROM_HERE,
 270         base::Bind(
 271           &base::WaitableEvent::Signal,
 272           base::Unretained(&io_thread_work_done)));
 273     io_thread_work_done.Wait();
 274   }
 275
 276   scoped_ptr<MockInterceptCallbackReceiver> mock_callback_receiver_;
 277   TestIOThreadState* io_thread_state_;
 278 };
 279
 280 TEST_F(InterceptNavigationResourceThrottleTest,
 281        RequestDeferredAndResumedIfNavigationNotIgnored) {
 282   bool defer = false;
 283   SetUpWebContentsDelegateAndDrainRunLoop(DontIgnoreNavigation, &defer);
 284
 285   EXPECT_TRUE(defer);
 286   ASSERT_TRUE(io_thread_state_);
 287   EXPECT_TRUE(io_thread_state_->request_resumed());
 288 }
 289
 290 TEST_F(InterceptNavigationResourceThrottleTest,
 291        RequestDeferredAndCancelledIfNavigationIgnored) {
 292   bool defer = false;
 293   SetUpWebContentsDelegateAndDrainRunLoop(IgnoreNavigation, &defer);
 294
 295   EXPECT_TRUE(defer);
 296   ASSERT_TRUE(io_thread_state_);
 297   EXPECT_TRUE(io_thread_state_->request_cancelled());
 298 }
 299
 300 TEST_F(InterceptNavigationResourceThrottleTest,
 301        NoCallbackMadeIfContentsDeletedWhileThrottleRunning) {
 302   bool defer = false;
 303
 304   // The tested scenario is when the WebContents is deleted after the
 305   // ResourceThrottle has finished processing on the IO thread but before the
 306   // UI thread callback has been processed.  Since both threads in this test
 307   // are serviced by one message loop, the post order is the execution order.
 308   EXPECT_CALL(*mock_callback_receiver_,
 309               ShouldIgnoreNavigation(_, _))
 310       .Times(0);
 311
 312   content::BrowserThread::PostTask(
 313       content::BrowserThread::IO,
 314       FROM_HERE,
 315       base::Bind(
 316           &InterceptNavigationResourceThrottleTest::
 317           RunThrottleWillStartRequestOnIOThread,
 318           base::Unretained(this),
 319           GURL(kTestUrl),
 320           "GET",
 321           REDIRECT_MODE_NO_REDIRECT,
 322           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
 323           web_contents()->GetMainFrame()->GetRoutingID(),
 324           base::Unretained(&defer)));
 325
 326   content::BrowserThread::PostTask(
 327       content::BrowserThread::UI,
 328       FROM_HERE,
 329       base::Bind(
 330           &RenderViewHostTestHarness::DeleteContents,
 331           base::Unretained(this)));
 332
 333   // The WebContents will now be deleted and only after that will the UI-thread
 334   // callback posted by the ResourceThrottle be executed.
 335   base::RunLoop().RunUntilIdle();
 336
 337   EXPECT_TRUE(defer);
 338   ASSERT_TRUE(io_thread_state_);
 339   EXPECT_TRUE(io_thread_state_->request_resumed());
 340 }
 341
 342 TEST_F(InterceptNavigationResourceThrottleTest,
 343        RequestNotDeferredForRequestNotAssociatedWithARenderView) {
 344   bool defer = false;
 345
 346   content::BrowserThread::PostTask(
 347       content::BrowserThread::IO,
 348       FROM_HERE,
 349       base::Bind(
 350           &InterceptNavigationResourceThrottleTest::
 351               RunThrottleWillStartRequestOnIOThread,
 352           base::Unretained(this),
 353           GURL(kTestUrl),
 354           "GET",
 355           REDIRECT_MODE_NO_REDIRECT,
 356           MSG_ROUTING_NONE,
 357           MSG_ROUTING_NONE,
 358           base::Unretained(&defer)));
 359
 360   // Wait for the request to finish processing.
 361   base::RunLoop().RunUntilIdle();
 362
 363   EXPECT_FALSE(defer);
 364 }
 365
 366 TEST_F(InterceptNavigationResourceThrottleTest,
 367        CallbackCalledWithFilteredUrl) {
 368   bool defer = false;
 369
 370   ON_CALL(*mock_callback_receiver_,
 371           ShouldIgnoreNavigation(_, NavigationParamsUrlIsSafe()))
 372       .WillByDefault(Return(false));
 373   EXPECT_CALL(*mock_callback_receiver_,
 374               ShouldIgnoreNavigation(_, NavigationParamsUrlIsSafe()))
 375       .Times(1);
 376
 377   content::BrowserThread::PostTask(
 378       content::BrowserThread::IO,
 379       FROM_HERE,
 380       base::Bind(
 381           &InterceptNavigationResourceThrottleTest::
 382               RunThrottleWillStartRequestOnIOThread,
 383           base::Unretained(this),
 384           GURL(kUnsafeTestUrl),
 385           "GET",
 386           REDIRECT_MODE_NO_REDIRECT,
 387           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
 388           web_contents()->GetMainFrame()->GetRoutingID(),
 389           base::Unretained(&defer)));
 390
 391   // Wait for the request to finish processing.
 392   base::RunLoop().RunUntilIdle();
 393 }
 394
 395 TEST_F(InterceptNavigationResourceThrottleTest,
 396        CallbackIsPostFalseForGet) {
 397   bool defer = false;
 398
 399   EXPECT_CALL(*mock_callback_receiver_,
 400               ShouldIgnoreNavigation(_, AllOf(
 401                   NavigationParamsUrlIsSafe(),
 402                   Property(&NavigationParams::is_post, Eq(false)))))
 403       .WillOnce(Return(false));
 404
 405   content::BrowserThread::PostTask(
 406       content::BrowserThread::IO,
 407       FROM_HERE,
 408       base::Bind(
 409           &InterceptNavigationResourceThrottleTest::
 410               RunThrottleWillStartRequestOnIOThread,
 411           base::Unretained(this),
 412           GURL(kTestUrl),
 413           "GET",
 414           REDIRECT_MODE_NO_REDIRECT,
 415           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
 416           web_contents()->GetMainFrame()->GetRoutingID(),
 417           base::Unretained(&defer)));
 418
 419   // Wait for the request to finish processing.
 420   base::RunLoop().RunUntilIdle();
 421 }
 422
 423 TEST_F(InterceptNavigationResourceThrottleTest,
 424        CallbackIsPostTrueForPost) {
 425   bool defer = false;
 426
 427   EXPECT_CALL(*mock_callback_receiver_,
 428               ShouldIgnoreNavigation(_, AllOf(
 429                   NavigationParamsUrlIsSafe(),
 430                   Property(&NavigationParams::is_post, Eq(true)))))
 431       .WillOnce(Return(false));
 432
 433   content::BrowserThread::PostTask(
 434       content::BrowserThread::IO,
 435       FROM_HERE,
 436       base::Bind(
 437           &InterceptNavigationResourceThrottleTest::
 438               RunThrottleWillStartRequestOnIOThread,
 439           base::Unretained(this),
 440           GURL(kTestUrl),
 441           "POST",
 442           REDIRECT_MODE_NO_REDIRECT,
 443           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
 444           web_contents()->GetMainFrame()->GetRoutingID(),
 445           base::Unretained(&defer)));
 446
 447   // Wait for the request to finish processing.
 448   base::RunLoop().RunUntilIdle();
 449 }
 450
 451 TEST_F(InterceptNavigationResourceThrottleTest,
 452        CallbackIsPostFalseForPostConvertedToGetBy302) {
 453   bool defer = false;
 454
 455   EXPECT_CALL(*mock_callback_receiver_,
 456               ShouldIgnoreNavigation(_, AllOf(
 457                   NavigationParamsUrlIsSafe(),
 458                   Property(&NavigationParams::is_post, Eq(false)))))
 459       .WillOnce(Return(false));
 460
 461   content::BrowserThread::PostTask(
 462       content::BrowserThread::IO,
 463       FROM_HERE,
 464       base::Bind(
 465           &InterceptNavigationResourceThrottleTest::
 466               RunThrottleWillStartRequestOnIOThread,
 467           base::Unretained(this),
 468           GURL(kTestUrl),
 469           "POST",
 470           REDIRECT_MODE_302,
 471           web_contents()->GetRenderViewHost()->GetProcess()->GetID(),
 472           web_contents()->GetMainFrame()->GetRoutingID(),
 473           base::Unretained(&defer)));
 474
 475   // Wait for the request to finish processing.
 476   base::RunLoop().RunUntilIdle();
 477 }
 478
 479 }  // namespace navigation_interception