chrome/browser/extensions/api/web_request/web_request_apitest.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/command_line.h"
   6 #include "chrome/browser/chrome_notification_types.h"
   7 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
   8 #include "chrome/browser/extensions/extension_apitest.h"
   9 #include "chrome/browser/extensions/extension_service.h"
  10 #include "chrome/browser/extensions/extension_test_message_listener.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/ui/browser.h"
  13 #include "chrome/browser/ui/login/login_prompt.h"
  14 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  15 #include "chrome/test/base/ui_test_utils.h"
  16 #include "content/public/browser/notification_registrar.h"
  17 #include "content/public/browser/notification_service.h"
  18 #include "content/public/browser/render_view_host.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/test/browser_test_utils.h"
  21 #include "extensions/browser/extension_system.h"
  22 #include "extensions/common/features/feature.h"
  23 #include "net/dns/mock_host_resolver.h"
  24 #include "net/test/embedded_test_server/embedded_test_server.h"
  25 #include "third_party/WebKit/public/web/WebInputEvent.h"
  26
  27 using content::WebContents;
  28 using extensions::Feature;
  29
  30 namespace {
  31
  32 class CancelLoginDialog : public content::NotificationObserver {
  33  public:
  34   CancelLoginDialog() {
  35     registrar_.Add(this,
  36                    chrome::NOTIFICATION_AUTH_NEEDED,
  37                    content::NotificationService::AllSources());
  38   }
  39
  40   virtual ~CancelLoginDialog() {}
  41
  42   virtual void Observe(int type,
  43                        const content::NotificationSource& source,
  44                        const content::NotificationDetails& details) OVERRIDE {
  45     LoginHandler* handler =
  46         content::Details<LoginNotificationDetails>(details).ptr()->handler();
  47     handler->CancelAuth();
  48   }
  49
  50  private:
  51   content::NotificationRegistrar registrar_;
  52
  53  DISALLOW_COPY_AND_ASSIGN(CancelLoginDialog);
  54 };
  55
  56 }  // namespace
  57
  58 class ExtensionWebRequestApiTest : public ExtensionApiTest {
  59  public:
  60   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
  61     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
  62     host_resolver()->AddRule("*", "127.0.0.1");
  63   }
  64
  65   void RunPermissionTest(
  66       const char* extension_directory,
  67       bool load_extension_with_incognito_permission,
  68       bool wait_for_extension_loaded_in_incognito,
  69       const char* expected_content_regular_window,
  70       const char* exptected_content_incognito_window);
  71 };
  72
  73 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, WebRequestApi) {
  74   ASSERT_TRUE(StartEmbeddedTestServer());
  75   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_api.html")) << message_;
  76 }
  77
  78 // Fails often on Windows dbg bots. http://crbug.com/177163
  79 #if defined(OS_WIN)
  80 #define MAYBE_WebRequestSimple DISABLED_WebRequestSimple
  81 #else
  82 #define MAYBE_WebRequestSimple WebRequestSimple
  83 #endif  // defined(OS_WIN)
  84 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, MAYBE_WebRequestSimple) {
  85   ASSERT_TRUE(StartEmbeddedTestServer());
  86   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_simple.html")) <<
  87       message_;
  88 }
  89
  90 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, WebRequestComplex) {
  91   ASSERT_TRUE(StartEmbeddedTestServer());
  92   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_complex.html")) <<
  93       message_;
  94 }
  95
  96 // Flaky (sometimes crash): http://crbug.com/140976
  97 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
  98                        DISABLED_WebRequestAuthRequired) {
  99   CancelLoginDialog login_dialog_helper;
 100
 101   ASSERT_TRUE(StartEmbeddedTestServer());
 102   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_auth_required.html")) <<
 103       message_;
 104 }
 105
 106 // This test times out regularly on win_rel trybots. See http://crbug.com/122178
 107 #if defined(OS_WIN)
 108 #define MAYBE_WebRequestBlocking DISABLED_WebRequestBlocking
 109 #else
 110 #define MAYBE_WebRequestBlocking WebRequestBlocking
 111 #endif
 112 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, MAYBE_WebRequestBlocking) {
 113   ASSERT_TRUE(StartEmbeddedTestServer());
 114   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_blocking.html")) <<
 115       message_;
 116 }
 117
 118 // Fails often on Windows dbg bots. http://crbug.com/177163
 119 #if defined(OS_WIN)
 120 #define MAYBE_WebRequestNewTab DISABLED_WebRequestNewTab
 121 #else
 122 #define MAYBE_WebRequestNewTab WebRequestNewTab
 123 #endif  // defined(OS_WIN)
 124 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, MAYBE_WebRequestNewTab) {
 125   ASSERT_TRUE(StartEmbeddedTestServer());
 126   // Wait for the extension to set itself up and return control to us.
 127   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_newTab.html"))
 128       << message_;
 129
 130   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
 131   content::WaitForLoadStop(tab);
 132
 133   ResultCatcher catcher;
 134
 135   ExtensionService* service = extensions::ExtensionSystem::Get(
 136       browser()->profile())->extension_service();
 137   const extensions::Extension* extension =
 138       service->GetExtensionById(last_loaded_extension_id(), false);
 139   GURL url = extension->GetResourceURL("newTab/a.html");
 140
 141   ui_test_utils::NavigateToURL(browser(), url);
 142
 143   // There's a link on a.html with target=_blank. Click on it to open it in a
 144   // new tab.
 145   blink::WebMouseEvent mouse_event;
 146   mouse_event.type = blink::WebInputEvent::MouseDown;
 147   mouse_event.button = blink::WebMouseEvent::ButtonLeft;
 148   mouse_event.x = 7;
 149   mouse_event.y = 7;
 150   mouse_event.clickCount = 1;
 151   tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
 152   mouse_event.type = blink::WebInputEvent::MouseUp;
 153   tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
 154
 155   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 156 }
 157
 158 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, WebRequestDeclarative1) {
 159   ASSERT_TRUE(StartEmbeddedTestServer());
 160   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_declarative1.html"))
 161       << message_;
 162 }
 163
 164 // This test times out on XP. See http://crbug.com/178296
 165 #if defined(OS_WIN)
 166 #define MAYBE_WebRequestDeclarative2 DISABLED_WebRequestDeclarative2
 167 #else
 168 #define MAYBE_WebRequestDeclarative2 WebRequestDeclarative2
 169 #endif
 170 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
 171                        MAYBE_WebRequestDeclarative2) {
 172   ASSERT_TRUE(StartEmbeddedTestServer());
 173   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_declarative2.html"))
 174       << message_;
 175 }
 176
 177 void ExtensionWebRequestApiTest::RunPermissionTest(
 178     const char* extension_directory,
 179     bool load_extension_with_incognito_permission,
 180     bool wait_for_extension_loaded_in_incognito,
 181     const char* expected_content_regular_window,
 182     const char* exptected_content_incognito_window) {
 183   ResultCatcher catcher;
 184   catcher.RestrictToProfile(browser()->profile());
 185   ResultCatcher catcher_incognito;
 186   catcher_incognito.RestrictToProfile(
 187       browser()->profile()->GetOffTheRecordProfile());
 188
 189   ExtensionTestMessageListener listener("done", true);
 190   ExtensionTestMessageListener listener_incognito("done_incognito", true);
 191
 192   int load_extension_flags = kFlagNone;
 193   if (load_extension_with_incognito_permission)
 194     load_extension_flags |= kFlagEnableIncognito;
 195   ASSERT_TRUE(LoadExtensionWithFlags(
 196       test_data_dir_.AppendASCII("webrequest_permissions")
 197                     .AppendASCII(extension_directory),
 198       load_extension_flags));
 199
 200   // Test that navigation in regular window is properly redirected.
 201   EXPECT_TRUE(listener.WaitUntilSatisfied());
 202
 203   // This navigation should be redirected.
 204   ui_test_utils::NavigateToURL(
 205       browser(),
 206       embedded_test_server()->GetURL("/extensions/test_file.html"));
 207
 208   std::string body;
 209   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
 210   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 211         tab,
 212         "window.domAutomationController.send(document.body.textContent)",
 213         &body));
 214   EXPECT_EQ(expected_content_regular_window, body);
 215
 216   // Test that navigation in OTR window is properly redirected.
 217   Browser* otr_browser = ui_test_utils::OpenURLOffTheRecord(
 218       browser()->profile(), GURL("about:blank"));
 219
 220   if (wait_for_extension_loaded_in_incognito)
 221     EXPECT_TRUE(listener_incognito.WaitUntilSatisfied());
 222
 223   // This navigation should be redirected if
 224   // load_extension_with_incognito_permission is true.
 225   ui_test_utils::NavigateToURL(
 226       otr_browser,
 227       embedded_test_server()->GetURL("/extensions/test_file.html"));
 228
 229   body.clear();
 230   WebContents* otr_tab = otr_browser->tab_strip_model()->GetActiveWebContents();
 231   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 232       otr_tab,
 233       "window.domAutomationController.send(document.body.textContent)",
 234       &body));
 235   EXPECT_EQ(exptected_content_incognito_window, body);
 236 }
 237
 238 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
 239                        WebRequestDeclarativePermissionSpanning1) {
 240   // Test spanning with incognito permission.
 241   ASSERT_TRUE(StartEmbeddedTestServer());
 242   RunPermissionTest("spanning", true, false, "redirected1", "redirected1");
 243 }
 244
 245 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
 246                        WebRequestDeclarativePermissionSpanning2) {
 247   // Test spanning without incognito permission.
 248   ASSERT_TRUE(StartEmbeddedTestServer());
 249   RunPermissionTest("spanning", false, false, "redirected1", "");
 250 }
 251
 252
 253 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
 254                        WebRequestDeclarativePermissionSplit1) {
 255   // Test split with incognito permission.
 256   ASSERT_TRUE(StartEmbeddedTestServer());
 257   RunPermissionTest("split", true, true, "redirected1", "redirected2");
 258 }
 259
 260 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
 261                        WebRequestDeclarativePermissionSplit2) {
 262   // Test split without incognito permission.
 263   ASSERT_TRUE(StartEmbeddedTestServer());
 264   RunPermissionTest("split", false, false, "redirected1", "");
 265 }
 266
 267 // TODO(vabr): Cure these flaky tests, http://crbug.com/238179.
 268 #if !defined(NDEBUG)
 269 #define MAYBE_PostData1 DISABLED_PostData1
 270 #define MAYBE_PostData2 DISABLED_PostData2
 271 #else
 272 #define MAYBE_PostData1 PostData1
 273 #define MAYBE_PostData2 PostData2
 274 #endif
 275 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, MAYBE_PostData1) {
 276   // Test HTML form POST data access with the default and "url" encoding.
 277   ASSERT_TRUE(StartEmbeddedTestServer());
 278   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_post1.html")) <<
 279       message_;
 280 }
 281
 282 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, MAYBE_PostData2) {
 283   // Test HTML form POST data access with the multipart and plaintext encoding.
 284   ASSERT_TRUE(StartEmbeddedTestServer());
 285   ASSERT_TRUE(RunExtensionSubtest("webrequest", "test_post2.html")) <<
 286       message_;
 287 }
 288
 289 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
 290                        DeclarativeSendMessage) {
 291   ASSERT_TRUE(StartEmbeddedTestServer());
 292   ASSERT_TRUE(RunExtensionTest("webrequest_sendmessage")) << message_;
 293 }
 294
 295 // Check that reloading an extension that runs in incognito split mode and
 296 // has two active background pages with registered events does not crash the
 297 // browser. Regression test for http://crbug.com/224094
 298 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, IncognitoSplitModeReload) {
 299   ASSERT_TRUE(StartEmbeddedTestServer());
 300   // Wait for rules to be set up.
 301   ExtensionTestMessageListener listener("done", true);
 302   ExtensionTestMessageListener listener_incognito("done_incognito", true);
 303
 304   const extensions::Extension* extension = LoadExtensionWithFlags(
 305       test_data_dir_.AppendASCII("webrequest_reload"),
 306       kFlagEnableIncognito);
 307   ASSERT_TRUE(extension);
 308   ui_test_utils::OpenURLOffTheRecord(browser()->profile(), GURL("about:blank"));
 309
 310   EXPECT_TRUE(listener.WaitUntilSatisfied());
 311   EXPECT_TRUE(listener_incognito.WaitUntilSatisfied());
 312
 313   // Reload extension and wait for rules to be set up again. This should not
 314   // crash the browser.
 315   ExtensionTestMessageListener listener2("done", true);
 316   ExtensionTestMessageListener listener_incognito2("done_incognito", true);
 317
 318   ReloadExtension(extension->id());
 319
 320   EXPECT_TRUE(listener2.WaitUntilSatisfied());
 321   EXPECT_TRUE(listener_incognito2.WaitUntilSatisfied());
 322 }