chrome/renderer/content_settings_observer_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 "components/content_settings/core/common/content_settings.h"
   6 #include "chrome/common/render_messages.h"
   7 #include "chrome/renderer/content_settings_observer.h"
   8 #include "chrome/test/base/chrome_render_view_test.h"
   9 #include "content/public/renderer/render_view.h"
  10 #include "ipc/ipc_message_macros.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/WebKit/public/web/WebView.h"
  14
  15 using testing::_;
  16 using testing::DeleteArg;
  17
  18 namespace {
  19
  20 class MockContentSettingsObserver : public ContentSettingsObserver {
  21  public:
  22   explicit MockContentSettingsObserver(content::RenderFrame* render_frame);
  23
  24   virtual bool Send(IPC::Message* message);
  25
  26   MOCK_METHOD1(OnContentBlocked,
  27                void(ContentSettingsType));
  28
  29   MOCK_METHOD5(OnAllowDOMStorage,
  30                void(int, const GURL&, const GURL&, bool, IPC::Message*));
  31   GURL image_url_;
  32   std::string image_origin_;
  33 };
  34
  35 MockContentSettingsObserver::MockContentSettingsObserver(
  36     content::RenderFrame* render_frame)
  37     : ContentSettingsObserver(render_frame, NULL),
  38       image_url_("http://www.foo.com/image.jpg"),
  39       image_origin_("http://www.foo.com") {
  40 }
  41
  42 bool MockContentSettingsObserver::Send(IPC::Message* message) {
  43   IPC_BEGIN_MESSAGE_MAP(MockContentSettingsObserver, *message)
  44     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ContentBlocked, OnContentBlocked)
  45     IPC_MESSAGE_HANDLER_DELAY_REPLY(ChromeViewHostMsg_AllowDOMStorage,
  46                                     OnAllowDOMStorage)
  47     IPC_MESSAGE_UNHANDLED(ADD_FAILURE())
  48   IPC_END_MESSAGE_MAP()
  49
  50   // Our super class deletes the message.
  51   return RenderFrameObserver::Send(message);
  52 }
  53
  54 }  // namespace
  55
  56 TEST_F(ChromeRenderViewTest, DidBlockContentType) {
  57   MockContentSettingsObserver observer(view_->GetMainRenderFrame());
  58   EXPECT_CALL(observer,
  59               OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
  60   observer.DidBlockContentType(CONTENT_SETTINGS_TYPE_COOKIES);
  61
  62   // Blocking the same content type a second time shouldn't send a notification.
  63   observer.DidBlockContentType(CONTENT_SETTINGS_TYPE_COOKIES);
  64   ::testing::Mock::VerifyAndClearExpectations(&observer);
  65 }
  66
  67 // Tests that multiple invokations of AllowDOMStorage result in a single IPC.
  68 // Fails due to http://crbug.com/104300
  69 TEST_F(ChromeRenderViewTest, DISABLED_AllowDOMStorage) {
  70   // Load some HTML, so we have a valid security origin.
  71   LoadHTML("<html></html>");
  72   MockContentSettingsObserver observer(view_->GetMainRenderFrame());
  73   ON_CALL(observer,
  74           OnAllowDOMStorage(_, _, _, _, _)).WillByDefault(DeleteArg<4>());
  75   EXPECT_CALL(observer,
  76               OnAllowDOMStorage(_, _, _, _, _));
  77   observer.allowStorage(true);
  78
  79   // Accessing localStorage from the same origin again shouldn't result in a
  80   // new IPC.
  81   observer.allowStorage(true);
  82   ::testing::Mock::VerifyAndClearExpectations(&observer);
  83 }
  84
  85 // Regression test for http://crbug.com/35011
  86 TEST_F(ChromeRenderViewTest, JSBlockSentAfterPageLoad) {
  87   // 1. Load page with JS.
  88   std::string html = "<html>"
  89                      "<head>"
  90                      "<script>document.createElement('div');</script>"
  91                      "</head>"
  92                      "<body>"
  93                      "</body>"
  94                      "</html>";
  95   render_thread_->sink().ClearMessages();
  96   LoadHTML(html.c_str());
  97
  98   // 2. Block JavaScript.
  99   RendererContentSettingRules content_setting_rules;
 100   ContentSettingsForOneType& script_setting_rules =
 101       content_setting_rules.script_rules;
 102   script_setting_rules.push_back(
 103       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 104                                   ContentSettingsPattern::Wildcard(),
 105                                   CONTENT_SETTING_BLOCK,
 106                                   std::string(),
 107                                   false));
 108   ContentSettingsObserver* observer = ContentSettingsObserver::Get(
 109       view_->GetMainRenderFrame());
 110   observer->SetContentSettingRules(&content_setting_rules);
 111
 112   // Make sure no pending messages are in the queue.
 113   ProcessPendingMessages();
 114   render_thread_->sink().ClearMessages();
 115
 116   // 3. Reload page.
 117   std::string url_str = "data:text/html;charset=utf-8,";
 118   url_str.append(html);
 119   GURL url(url_str);
 120   Reload(url);
 121   ProcessPendingMessages();
 122
 123   // 4. Verify that the notification that javascript was blocked is sent after
 124   //    the navigation notification is sent.
 125   int navigation_index = -1;
 126   int block_index = -1;
 127   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 128     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 129     if (msg->type() == GetNavigationIPCType())
 130       navigation_index = i;
 131     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 132       block_index = i;
 133   }
 134   EXPECT_NE(-1, navigation_index);
 135   EXPECT_NE(-1, block_index);
 136   EXPECT_LT(navigation_index, block_index);
 137 }
 138
 139 TEST_F(ChromeRenderViewTest, PluginsTemporarilyAllowed) {
 140   // Load some HTML.
 141   LoadHTML("<html>Foo</html>");
 142
 143   std::string foo_plugin = "foo";
 144   std::string bar_plugin = "bar";
 145
 146   ContentSettingsObserver* observer =
 147       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 148   EXPECT_FALSE(observer->IsPluginTemporarilyAllowed(foo_plugin));
 149
 150   // Temporarily allow the "foo" plugin.
 151   observer->OnLoadBlockedPlugins(foo_plugin);
 152   EXPECT_TRUE(observer->IsPluginTemporarilyAllowed(foo_plugin));
 153   EXPECT_FALSE(observer->IsPluginTemporarilyAllowed(bar_plugin));
 154
 155   // Simulate a navigation within the page.
 156   DidNavigateWithinPage(GetMainFrame(), true);
 157   EXPECT_TRUE(observer->IsPluginTemporarilyAllowed(foo_plugin));
 158   EXPECT_FALSE(observer->IsPluginTemporarilyAllowed(bar_plugin));
 159
 160   // Navigate to a different page.
 161   LoadHTML("<html>Bar</html>");
 162   EXPECT_FALSE(observer->IsPluginTemporarilyAllowed(foo_plugin));
 163   EXPECT_FALSE(observer->IsPluginTemporarilyAllowed(bar_plugin));
 164
 165   // Temporarily allow all plugins.
 166   observer->OnLoadBlockedPlugins(std::string());
 167   EXPECT_TRUE(observer->IsPluginTemporarilyAllowed(foo_plugin));
 168   EXPECT_TRUE(observer->IsPluginTemporarilyAllowed(bar_plugin));
 169 }
 170
 171 TEST_F(ChromeRenderViewTest, ImagesBlockedByDefault) {
 172   MockContentSettingsObserver mock_observer(view_->GetMainRenderFrame());
 173
 174   // Load some HTML.
 175   LoadHTML("<html>Foo</html>");
 176
 177   // Set the default image blocking setting.
 178   RendererContentSettingRules content_setting_rules;
 179   ContentSettingsForOneType& image_setting_rules =
 180       content_setting_rules.image_rules;
 181   image_setting_rules.push_back(
 182       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 183                                   ContentSettingsPattern::Wildcard(),
 184                                   CONTENT_SETTING_BLOCK,
 185                                   std::string(),
 186                                   false));
 187
 188   ContentSettingsObserver* observer = ContentSettingsObserver::Get(
 189       view_->GetMainRenderFrame());
 190   observer->SetContentSettingRules(&content_setting_rules);
 191   EXPECT_CALL(mock_observer,
 192               OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES));
 193   EXPECT_FALSE(observer->allowImage(true, mock_observer.image_url_));
 194   ::testing::Mock::VerifyAndClearExpectations(&observer);
 195
 196   // Create an exception which allows the image.
 197   image_setting_rules.insert(
 198       image_setting_rules.begin(),
 199       ContentSettingPatternSource(
 200           ContentSettingsPattern::Wildcard(),
 201           ContentSettingsPattern::FromString(mock_observer.image_origin_),
 202           CONTENT_SETTING_ALLOW,
 203           std::string(),
 204           false));
 205
 206   EXPECT_CALL(
 207       mock_observer,
 208       OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES)).Times(0);
 209   EXPECT_TRUE(observer->allowImage(true, mock_observer.image_url_));
 210   ::testing::Mock::VerifyAndClearExpectations(&observer);
 211 }
 212
 213 TEST_F(ChromeRenderViewTest, ImagesAllowedByDefault) {
 214   MockContentSettingsObserver mock_observer(view_->GetMainRenderFrame());
 215
 216   // Load some HTML.
 217   LoadHTML("<html>Foo</html>");
 218
 219   // Set the default image blocking setting.
 220   RendererContentSettingRules content_setting_rules;
 221   ContentSettingsForOneType& image_setting_rules =
 222       content_setting_rules.image_rules;
 223   image_setting_rules.push_back(
 224       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 225                                   ContentSettingsPattern::Wildcard(),
 226                                   CONTENT_SETTING_ALLOW,
 227                                   std::string(),
 228                                   false));
 229
 230   ContentSettingsObserver* observer =
 231       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 232   observer->SetContentSettingRules(&content_setting_rules);
 233   EXPECT_CALL(
 234       mock_observer,
 235       OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES)).Times(0);
 236   EXPECT_TRUE(observer->allowImage(true, mock_observer.image_url_));
 237   ::testing::Mock::VerifyAndClearExpectations(&observer);
 238
 239   // Create an exception which blocks the image.
 240   image_setting_rules.insert(
 241       image_setting_rules.begin(),
 242       ContentSettingPatternSource(
 243           ContentSettingsPattern::Wildcard(),
 244           ContentSettingsPattern::FromString(mock_observer.image_origin_),
 245           CONTENT_SETTING_BLOCK,
 246           std::string(),
 247           false));
 248   EXPECT_CALL(mock_observer,
 249               OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES));
 250   EXPECT_FALSE(observer->allowImage(true, mock_observer.image_url_));
 251   ::testing::Mock::VerifyAndClearExpectations(&observer);
 252 }
 253
 254 TEST_F(ChromeRenderViewTest, ContentSettingsBlockScripts) {
 255   // Set the content settings for scripts.
 256   RendererContentSettingRules content_setting_rules;
 257   ContentSettingsForOneType& script_setting_rules =
 258       content_setting_rules.script_rules;
 259   script_setting_rules.push_back(
 260       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 261                                   ContentSettingsPattern::Wildcard(),
 262                                   CONTENT_SETTING_BLOCK,
 263                                   std::string(),
 264                                   false));
 265
 266   ContentSettingsObserver* observer =
 267       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 268   observer->SetContentSettingRules(&content_setting_rules);
 269
 270   // Load a page which contains a script.
 271   std::string html = "<html>"
 272                      "<head>"
 273                      "<script src='data:foo'></script>"
 274                      "</head>"
 275                      "<body>"
 276                      "</body>"
 277                      "</html>";
 278   LoadHTML(html.c_str());
 279
 280   // Verify that the script was blocked.
 281   bool was_blocked = false;
 282   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 283     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 284     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 285       was_blocked = true;
 286   }
 287   EXPECT_TRUE(was_blocked);
 288 }
 289
 290 TEST_F(ChromeRenderViewTest, ContentSettingsAllowScripts) {
 291   // Set the content settings for scripts.
 292   RendererContentSettingRules content_setting_rules;
 293   ContentSettingsForOneType& script_setting_rules =
 294       content_setting_rules.script_rules;
 295   script_setting_rules.push_back(
 296       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 297                                   ContentSettingsPattern::Wildcard(),
 298                                   CONTENT_SETTING_ALLOW,
 299                                   std::string(),
 300                                   false));
 301
 302   ContentSettingsObserver* observer =
 303       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 304   observer->SetContentSettingRules(&content_setting_rules);
 305
 306   // Load a page which contains a script.
 307   std::string html = "<html>"
 308                      "<head>"
 309                      "<script src='data:foo'></script>"
 310                      "</head>"
 311                      "<body>"
 312                      "</body>"
 313                      "</html>";
 314   LoadHTML(html.c_str());
 315
 316   // Verify that the script was not blocked.
 317   bool was_blocked = false;
 318   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 319     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 320     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 321       was_blocked = true;
 322   }
 323   EXPECT_FALSE(was_blocked);
 324 }
 325
 326 TEST_F(ChromeRenderViewTest, ContentSettingsInterstitialPages) {
 327   MockContentSettingsObserver mock_observer(view_->GetMainRenderFrame());
 328   // Block scripts.
 329   RendererContentSettingRules content_setting_rules;
 330   ContentSettingsForOneType& script_setting_rules =
 331       content_setting_rules.script_rules;
 332   script_setting_rules.push_back(
 333       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 334                                   ContentSettingsPattern::Wildcard(),
 335                                   CONTENT_SETTING_BLOCK,
 336                                   std::string(),
 337                                   false));
 338   // Block images.
 339   ContentSettingsForOneType& image_setting_rules =
 340       content_setting_rules.image_rules;
 341   image_setting_rules.push_back(
 342       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 343                                   ContentSettingsPattern::Wildcard(),
 344                                   CONTENT_SETTING_BLOCK,
 345                                   std::string(),
 346                                   false));
 347
 348   ContentSettingsObserver* observer =
 349       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 350   observer->SetContentSettingRules(&content_setting_rules);
 351   observer->OnSetAsInterstitial();
 352
 353   // Load a page which contains a script.
 354   std::string html = "<html>"
 355                      "<head>"
 356                      "<script src='data:foo'></script>"
 357                      "</head>"
 358                      "<body>"
 359                      "</body>"
 360                      "</html>";
 361   LoadHTML(html.c_str());
 362
 363   // Verify that the script was allowed.
 364   bool was_blocked = false;
 365   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 366     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 367     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 368       was_blocked = true;
 369   }
 370   EXPECT_FALSE(was_blocked);
 371
 372   // Verify that images are allowed.
 373   EXPECT_CALL(
 374       mock_observer,
 375       OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES)).Times(0);
 376   EXPECT_TRUE(observer->allowImage(true, mock_observer.image_url_));
 377   ::testing::Mock::VerifyAndClearExpectations(&observer);
 378 }