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_METHOD2(OnContentBlocked,
  27                void(ContentSettingsType, const base::string16&));
  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, false),
  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, OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES,
  59                                          base::string16()));
  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, base::string16()));
 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(mock_observer, OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES,
 207                                               base::string16())).Times(0);
 208   EXPECT_TRUE(observer->allowImage(true, mock_observer.image_url_));
 209   ::testing::Mock::VerifyAndClearExpectations(&observer);
 210 }
 211
 212 TEST_F(ChromeRenderViewTest, ImagesAllowedByDefault) {
 213   MockContentSettingsObserver mock_observer(view_->GetMainRenderFrame());
 214
 215   // Load some HTML.
 216   LoadHTML("<html>Foo</html>");
 217
 218   // Set the default image blocking setting.
 219   RendererContentSettingRules content_setting_rules;
 220   ContentSettingsForOneType& image_setting_rules =
 221       content_setting_rules.image_rules;
 222   image_setting_rules.push_back(
 223       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 224                                   ContentSettingsPattern::Wildcard(),
 225                                   CONTENT_SETTING_ALLOW,
 226                                   std::string(),
 227                                   false));
 228
 229   ContentSettingsObserver* observer =
 230       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 231   observer->SetContentSettingRules(&content_setting_rules);
 232   EXPECT_CALL(mock_observer, OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES,
 233                                               base::string16())).Times(0);
 234   EXPECT_TRUE(observer->allowImage(true, mock_observer.image_url_));
 235   ::testing::Mock::VerifyAndClearExpectations(&observer);
 236
 237   // Create an exception which blocks the image.
 238   image_setting_rules.insert(
 239       image_setting_rules.begin(),
 240       ContentSettingPatternSource(
 241           ContentSettingsPattern::Wildcard(),
 242           ContentSettingsPattern::FromString(mock_observer.image_origin_),
 243           CONTENT_SETTING_BLOCK,
 244           std::string(),
 245           false));
 246   EXPECT_CALL(mock_observer,
 247               OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES, base::string16()));
 248   EXPECT_FALSE(observer->allowImage(true, mock_observer.image_url_));
 249   ::testing::Mock::VerifyAndClearExpectations(&observer);
 250 }
 251
 252 TEST_F(ChromeRenderViewTest, ContentSettingsBlockScripts) {
 253   // Set the content settings for scripts.
 254   RendererContentSettingRules content_setting_rules;
 255   ContentSettingsForOneType& script_setting_rules =
 256       content_setting_rules.script_rules;
 257   script_setting_rules.push_back(
 258       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 259                                   ContentSettingsPattern::Wildcard(),
 260                                   CONTENT_SETTING_BLOCK,
 261                                   std::string(),
 262                                   false));
 263
 264   ContentSettingsObserver* observer =
 265       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 266   observer->SetContentSettingRules(&content_setting_rules);
 267
 268   // Load a page which contains a script.
 269   std::string html = "<html>"
 270                      "<head>"
 271                      "<script src='data:foo'></script>"
 272                      "</head>"
 273                      "<body>"
 274                      "</body>"
 275                      "</html>";
 276   LoadHTML(html.c_str());
 277
 278   // Verify that the script was blocked.
 279   bool was_blocked = false;
 280   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 281     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 282     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 283       was_blocked = true;
 284   }
 285   EXPECT_TRUE(was_blocked);
 286 }
 287
 288 TEST_F(ChromeRenderViewTest, ContentSettingsAllowScripts) {
 289   // Set the content settings for scripts.
 290   RendererContentSettingRules content_setting_rules;
 291   ContentSettingsForOneType& script_setting_rules =
 292       content_setting_rules.script_rules;
 293   script_setting_rules.push_back(
 294       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 295                                   ContentSettingsPattern::Wildcard(),
 296                                   CONTENT_SETTING_ALLOW,
 297                                   std::string(),
 298                                   false));
 299
 300   ContentSettingsObserver* observer =
 301       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 302   observer->SetContentSettingRules(&content_setting_rules);
 303
 304   // Load a page which contains a script.
 305   std::string html = "<html>"
 306                      "<head>"
 307                      "<script src='data:foo'></script>"
 308                      "</head>"
 309                      "<body>"
 310                      "</body>"
 311                      "</html>";
 312   LoadHTML(html.c_str());
 313
 314   // Verify that the script was not blocked.
 315   bool was_blocked = false;
 316   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 317     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 318     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 319       was_blocked = true;
 320   }
 321   EXPECT_FALSE(was_blocked);
 322 }
 323
 324 TEST_F(ChromeRenderViewTest, ContentSettingsInterstitialPages) {
 325   MockContentSettingsObserver mock_observer(view_->GetMainRenderFrame());
 326   // Block scripts.
 327   RendererContentSettingRules content_setting_rules;
 328   ContentSettingsForOneType& script_setting_rules =
 329       content_setting_rules.script_rules;
 330   script_setting_rules.push_back(
 331       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 332                                   ContentSettingsPattern::Wildcard(),
 333                                   CONTENT_SETTING_BLOCK,
 334                                   std::string(),
 335                                   false));
 336   // Block images.
 337   ContentSettingsForOneType& image_setting_rules =
 338       content_setting_rules.image_rules;
 339   image_setting_rules.push_back(
 340       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
 341                                   ContentSettingsPattern::Wildcard(),
 342                                   CONTENT_SETTING_BLOCK,
 343                                   std::string(),
 344                                   false));
 345
 346   ContentSettingsObserver* observer =
 347       ContentSettingsObserver::Get(view_->GetMainRenderFrame());
 348   observer->SetContentSettingRules(&content_setting_rules);
 349   observer->OnSetAsInterstitial();
 350
 351   // Load a page which contains a script.
 352   std::string html = "<html>"
 353                      "<head>"
 354                      "<script src='data:foo'></script>"
 355                      "</head>"
 356                      "<body>"
 357                      "</body>"
 358                      "</html>";
 359   LoadHTML(html.c_str());
 360
 361   // Verify that the script was allowed.
 362   bool was_blocked = false;
 363   for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
 364     const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 365     if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
 366       was_blocked = true;
 367   }
 368   EXPECT_FALSE(was_blocked);
 369
 370   // Verify that images are allowed.
 371   EXPECT_CALL(mock_observer, OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES,
 372                                               base::string16())).Times(0);
 373   EXPECT_TRUE(observer->allowImage(true, mock_observer.image_url_));
 374   ::testing::Mock::VerifyAndClearExpectations(&observer);
 375 }