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 <string>
6
7#include "base/compiler_specific.h"
8#include "base/strings/string_number_conversions.h"
9#include "base/strings/stringprintf.h"
10#include "base/strings/utf_string_conversions.h"
11#include "chrome/browser/chrome_notification_types.h"
12#include "chrome/browser/content_settings/content_settings_usages_state.h"
13#include "chrome/browser/content_settings/host_content_settings_map.h"
14#include "chrome/browser/content_settings/tab_specific_content_settings.h"
15#include "chrome/browser/infobars/confirm_infobar_delegate.h"
16#include "chrome/browser/infobars/infobar.h"
17#include "chrome/browser/infobars/infobar_service.h"
18#include "chrome/browser/profiles/profile.h"
19#include "chrome/browser/ui/browser.h"
20#include "chrome/browser/ui/browser_commands.h"
21#include "chrome/browser/ui/tabs/tab_strip_model.h"
22#include "chrome/common/chrome_paths.h"
23#include "chrome/common/content_settings_pattern.h"
24#include "chrome/test/base/in_process_browser_test.h"
25#include "chrome/test/base/ui_test_utils.h"
26#include "content/public/browser/dom_operation_notification_details.h"
27#include "content/public/browser/navigation_controller.h"
28#include "content/public/browser/notification_details.h"
29#include "content/public/browser/notification_service.h"
30#include "content/public/browser/render_view_host.h"
31#include "content/public/browser/web_contents.h"
32#include "content/public/test/browser_test_utils.h"
33#include "net/base/net_util.h"
34#include "net/test/embedded_test_server/embedded_test_server.h"
35
36using content::DomOperationNotificationDetails;
37using content::NavigationController;
38using content::WebContents;
39
40namespace {
41
42
43// IFrameLoader ---------------------------------------------------------------
44
45// Used to block until an iframe is loaded via a javascript call.
46// Note: NavigateToURLBlockUntilNavigationsComplete doesn't seem to work for
47// multiple embedded iframes, as notifications seem to be 'batched'. Instead, we
48// load and wait one single frame here by calling a javascript function.
49class IFrameLoader : public content::NotificationObserver {
50 public:
51  IFrameLoader(Browser* browser, int iframe_id, const GURL& url);
52  virtual ~IFrameLoader();
53
54  // content::NotificationObserver:
55  virtual void Observe(int type,
56                       const content::NotificationSource& source,
57                       const content::NotificationDetails& details) OVERRIDE;
58
59  const GURL& iframe_url() const { return iframe_url_; }
60
61 private:
62  content::NotificationRegistrar registrar_;
63
64  // If true the navigation has completed.
65  bool navigation_completed_;
66
67  // If true the javascript call has completed.
68  bool javascript_completed_;
69
70  std::string javascript_response_;
71
72  // The URL for the iframe we just loaded.
73  GURL iframe_url_;
74
75  DISALLOW_COPY_AND_ASSIGN(IFrameLoader);
76};
77
78IFrameLoader::IFrameLoader(Browser* browser, int iframe_id, const GURL& url)
79    : navigation_completed_(false),
80      javascript_completed_(false) {
81  WebContents* web_contents =
82      browser->tab_strip_model()->GetActiveWebContents();
83  NavigationController* controller = &web_contents->GetController();
84  registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
85                 content::Source<NavigationController>(controller));
86  registrar_.Add(this, content::NOTIFICATION_DOM_OPERATION_RESPONSE,
87                 content::NotificationService::AllSources());
88  std::string script(base::StringPrintf(
89      "window.domAutomationController.setAutomationId(0);"
90      "window.domAutomationController.send(addIFrame(%d, \"%s\"));",
91      iframe_id, url.spec().c_str()));
92  web_contents->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
93      base::string16(), UTF8ToUTF16(script));
94  content::RunMessageLoop();
95
96  EXPECT_EQ(base::StringPrintf("\"%d\"", iframe_id), javascript_response_);
97  registrar_.RemoveAll();
98  // Now that we loaded the iframe, let's fetch its src.
99  script = base::StringPrintf(
100      "window.domAutomationController.send(getIFrameSrc(%d))", iframe_id);
101  std::string iframe_src;
102  EXPECT_TRUE(content::ExecuteScriptAndExtractString(web_contents, script,
103                                                     &iframe_src));
104  iframe_url_ = GURL(iframe_src);
105}
106
107IFrameLoader::~IFrameLoader() {
108}
109
110void IFrameLoader::Observe(int type,
111                           const content::NotificationSource& source,
112                           const content::NotificationDetails& details) {
113  if (type == content::NOTIFICATION_LOAD_STOP) {
114    navigation_completed_ = true;
115  } else if (type == content::NOTIFICATION_DOM_OPERATION_RESPONSE) {
116    content::Details<DomOperationNotificationDetails> dom_op_details(details);
117    javascript_response_ = dom_op_details->json;
118    javascript_completed_ = true;
119  }
120  if (javascript_completed_ && navigation_completed_)
121    base::MessageLoopForUI::current()->Quit();
122}
123
124
125// GeolocationNotificationObserver --------------------------------------------
126
127class GeolocationNotificationObserver : public content::NotificationObserver {
128 public:
129  // If |wait_for_infobar| is true, AddWatchAndWaitForNotification will block
130  // until the infobar has been displayed; otherwise it will block until the
131  // navigation is completed.
132  explicit GeolocationNotificationObserver(bool wait_for_infobar);
133  virtual ~GeolocationNotificationObserver();
134
135  // content::NotificationObserver:
136  virtual void Observe(int type,
137                       const content::NotificationSource& source,
138                       const content::NotificationDetails& details) OVERRIDE;
139
140  void AddWatchAndWaitForNotification(content::RenderViewHost* render_view_host,
141                                      const std::string& iframe_xpath);
142
143  bool has_infobar() const { return !!infobar_; }
144  InfoBar* infobar() { return infobar_; }
145
146 private:
147  content::NotificationRegistrar registrar_;
148  bool wait_for_infobar_;
149  InfoBar* infobar_;
150  bool navigation_started_;
151  bool navigation_completed_;
152  std::string javascript_response_;
153
154  DISALLOW_COPY_AND_ASSIGN(GeolocationNotificationObserver);
155};
156
157GeolocationNotificationObserver::GeolocationNotificationObserver(
158    bool wait_for_infobar)
159    : wait_for_infobar_(wait_for_infobar),
160      infobar_(NULL),
161      navigation_started_(false),
162      navigation_completed_(false) {
163  registrar_.Add(this, content::NOTIFICATION_DOM_OPERATION_RESPONSE,
164                 content::NotificationService::AllSources());
165  if (wait_for_infobar) {
166    registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
167                   content::NotificationService::AllSources());
168  } else {
169    registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
170                   content::NotificationService::AllSources());
171    registrar_.Add(this, content::NOTIFICATION_LOAD_START,
172                   content::NotificationService::AllSources());
173    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
174                   content::NotificationService::AllSources());
175  }
176}
177
178GeolocationNotificationObserver::~GeolocationNotificationObserver() {
179}
180
181void GeolocationNotificationObserver::Observe(
182    int type,
183    const content::NotificationSource& source,
184    const content::NotificationDetails& details) {
185  if (type == chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED) {
186    infobar_ = content::Details<InfoBar::AddedDetails>(details).ptr();
187    ASSERT_FALSE(infobar_->delegate()->GetIcon().IsEmpty());
188    ASSERT_TRUE(infobar_->delegate()->AsConfirmInfoBarDelegate());
189  } else if (type == content::NOTIFICATION_DOM_OPERATION_RESPONSE) {
190    content::Details<DomOperationNotificationDetails> dom_op_details(details);
191    javascript_response_ = dom_op_details->json;
192    LOG(WARNING) << "javascript_response " << javascript_response_;
193  } else if ((type == content::NOTIFICATION_NAV_ENTRY_COMMITTED) ||
194             (type == content::NOTIFICATION_LOAD_START)) {
195    navigation_started_ = true;
196  } else if ((type == content::NOTIFICATION_LOAD_STOP) && navigation_started_) {
197    navigation_started_ = false;
198    navigation_completed_ = true;
199  }
200
201  // We're either waiting for just the infobar, or for both a javascript
202  // prompt and response.
203  if ((wait_for_infobar_ && infobar_) ||
204      (navigation_completed_ && !javascript_response_.empty()))
205    base::MessageLoopForUI::current()->Quit();
206}
207
208void GeolocationNotificationObserver::AddWatchAndWaitForNotification(
209    content::RenderViewHost* render_view_host,
210    const std::string& iframe_xpath) {
211  LOG(WARNING) << "will add geolocation watch";
212  std::string script(
213      "window.domAutomationController.setAutomationId(0);"
214      "window.domAutomationController.send(geoStart());");
215  render_view_host->ExecuteJavascriptInWebFrame(UTF8ToUTF16(iframe_xpath),
216                                                UTF8ToUTF16(script));
217  content::RunMessageLoop();
218  registrar_.RemoveAll();
219  LOG(WARNING) << "got geolocation watch" << javascript_response_;
220  EXPECT_NE("\"0\"", javascript_response_);
221  EXPECT_TRUE(wait_for_infobar_ ? (infobar_ != NULL) : navigation_completed_);
222}
223
224}  // namespace
225
226
227// GeolocationBrowserTest -----------------------------------------------------
228
229// This is a browser test for Geolocation.
230// It exercises various integration points from javascript <-> browser:
231// 1. Infobar is displayed when a geolocation is requested from an unauthorized
232// origin.
233// 2. Denying the infobar triggers the correct error callback.
234// 3. Allowing the infobar does not trigger an error, and allow a geoposition to
235// be passed to javascript.
236// 4. Permissions persisted in disk are respected.
237// 5. Incognito profiles don't use saved permissions.
238class GeolocationBrowserTest : public InProcessBrowserTest {
239 public:
240  enum InitializationOptions {
241    INITIALIZATION_NONE,
242    INITIALIZATION_OFFTHERECORD,
243    INITIALIZATION_NEWTAB,
244    INITIALIZATION_IFRAMES,
245  };
246
247  GeolocationBrowserTest();
248  virtual ~GeolocationBrowserTest();
249
250  // InProcessBrowserTest:
251  virtual void SetUpOnMainThread() OVERRIDE;
252  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE;
253
254  Browser* current_browser() { return current_browser_; }
255  void set_html_for_tests(const std::string& html_for_tests) {
256    html_for_tests_ = html_for_tests;
257  }
258  const std::string& iframe_xpath() const { return iframe_xpath_; }
259  void set_iframe_xpath(const std::string& iframe_xpath) {
260    iframe_xpath_ = iframe_xpath;
261  }
262  const GURL& current_url() const { return current_url_; }
263  const GURL& iframe_url(size_t i) const { return iframe_urls_[i]; }
264  double fake_latitude() const { return fake_latitude_; }
265  double fake_longitude() const { return fake_longitude_; }
266
267  // Initializes the test server and navigates to the initial url.
268  bool Initialize(InitializationOptions options) WARN_UNUSED_RESULT;
269
270  // Loads the specified number of iframes.
271  void LoadIFrames(int number_iframes);
272
273  // Start watching for geolocation notifications. If |wait_for_infobar| is
274  // true, wait for the infobar to be displayed. Otherwise wait for a javascript
275  // response.
276  void AddGeolocationWatch(bool wait_for_infobar);
277
278  // Checks that no errors have been received in javascript, and checks that the
279  // position most recently received in javascript matches |latitude| and
280  // |longitude|.
281  void CheckGeoposition(double latitude, double longitude);
282
283  // For |requesting_url| if |allowed| is true accept the infobar. Otherwise
284  // cancel it.
285  void SetInfoBarResponse(const GURL& requesting_url, bool allowed);
286
287  // Executes |function| in |web_contents| and checks that the return value
288  // matches |expected|.
289  void CheckStringValueFromJavascriptForTab(const std::string& expected,
290                                            const std::string& function,
291                                            WebContents* web_contents);
292
293  // Executes |function| and checks that the return value matches |expected|.
294  void CheckStringValueFromJavascript(const std::string& expected,
295                                      const std::string& function);
296
297  // Sets a new position and sends a notification with the new position.
298  void NotifyGeoposition(double latitude, double longitude);
299
300 private:
301  InfoBar* infobar_;
302  Browser* current_browser_;
303  // path element of a URL referencing the html content for this test.
304  std::string html_for_tests_;
305  // This member defines the iframe (or top-level page, if empty) where the
306  // javascript calls will run.
307  std::string iframe_xpath_;
308  // The current url for the top level page.
309  GURL current_url_;
310  // If not empty, the GURLs for the iframes loaded by LoadIFrames().
311  std::vector<GURL> iframe_urls_;
312  double fake_latitude_;
313  double fake_longitude_;
314
315  DISALLOW_COPY_AND_ASSIGN(GeolocationBrowserTest);
316};
317
318GeolocationBrowserTest::GeolocationBrowserTest()
319  : infobar_(NULL),
320    current_browser_(NULL),
321    html_for_tests_("/geolocation/simple.html"),
322    fake_latitude_(1.23),
323    fake_longitude_(4.56) {
324}
325
326GeolocationBrowserTest::~GeolocationBrowserTest() {
327}
328
329void GeolocationBrowserTest::SetUpOnMainThread() {
330  ui_test_utils::OverrideGeolocation(fake_latitude_, fake_longitude_);
331}
332
333void GeolocationBrowserTest::TearDownInProcessBrowserTestFixture() {
334  LOG(WARNING) << "TearDownInProcessBrowserTestFixture. Test Finished.";
335}
336
337bool GeolocationBrowserTest::Initialize(InitializationOptions options) {
338  if (!embedded_test_server()->Started() &&
339      !embedded_test_server()->InitializeAndWaitUntilReady()) {
340    ADD_FAILURE() << "Test server failed to start.";
341    return false;
342  }
343
344  current_url_ = embedded_test_server()->GetURL(html_for_tests_);
345  LOG(WARNING) << "before navigate";
346  if (options == INITIALIZATION_OFFTHERECORD) {
347    current_browser_ = ui_test_utils::OpenURLOffTheRecord(
348        browser()->profile(), current_url_);
349  } else {
350    current_browser_ = browser();
351    if (options == INITIALIZATION_NEWTAB)
352      chrome::NewTab(current_browser_);
353    ui_test_utils::NavigateToURL(current_browser_, current_url_);
354  }
355  LOG(WARNING) << "after navigate";
356
357  EXPECT_TRUE(current_browser_);
358  return !!current_browser_;
359}
360
361void GeolocationBrowserTest::LoadIFrames(int number_iframes) {
362  // Limit to 3 iframes.
363  DCHECK_LT(0, number_iframes);
364  DCHECK_LE(number_iframes, 3);
365  iframe_urls_.resize(number_iframes);
366  for (int i = 0; i < number_iframes; ++i) {
367    IFrameLoader loader(current_browser_, i, GURL());
368    iframe_urls_[i] = loader.iframe_url();
369  }
370}
371
372void GeolocationBrowserTest::AddGeolocationWatch(bool wait_for_infobar) {
373  GeolocationNotificationObserver notification_observer(wait_for_infobar);
374  notification_observer.AddWatchAndWaitForNotification(
375      current_browser_->tab_strip_model()->GetActiveWebContents()->
376          GetRenderViewHost(),
377      iframe_xpath());
378  if (wait_for_infobar) {
379    EXPECT_TRUE(notification_observer.has_infobar());
380    infobar_ = notification_observer.infobar();
381  }
382}
383
384void GeolocationBrowserTest::CheckGeoposition(double latitude,
385                                              double longitude) {
386  // Checks we have no error.
387  CheckStringValueFromJavascript("0", "geoGetLastError()");
388  CheckStringValueFromJavascript(base::DoubleToString(latitude),
389                                 "geoGetLastPositionLatitude()");
390  CheckStringValueFromJavascript(base::DoubleToString(longitude),
391                                 "geoGetLastPositionLongitude()");
392}
393
394void GeolocationBrowserTest::SetInfoBarResponse(const GURL& requesting_url,
395                                                bool allowed) {
396  WebContents* web_contents =
397      current_browser_->tab_strip_model()->GetActiveWebContents();
398  TabSpecificContentSettings* content_settings =
399      TabSpecificContentSettings::FromWebContents(web_contents);
400  const ContentSettingsUsagesState& usages_state =
401      content_settings->geolocation_usages_state();
402  size_t state_map_size = usages_state.state_map().size();
403  ASSERT_TRUE(infobar_);
404  LOG(WARNING) << "will set infobar response";
405  {
406    content::WindowedNotificationObserver observer(
407        content::NOTIFICATION_LOAD_STOP,
408        content::Source<NavigationController>(&web_contents->GetController()));
409    if (allowed)
410      infobar_->delegate()->AsConfirmInfoBarDelegate()->Accept();
411    else
412      infobar_->delegate()->AsConfirmInfoBarDelegate()->Cancel();
413    observer.Wait();
414  }
415
416  InfoBarService::FromWebContents(web_contents)->RemoveInfoBar(infobar_);
417  LOG(WARNING) << "infobar response set";
418  infobar_ = NULL;
419  EXPECT_GT(usages_state.state_map().size(), state_map_size);
420  GURL requesting_origin(requesting_url.GetOrigin());
421  EXPECT_EQ(1U, usages_state.state_map().count(requesting_origin));
422  ContentSetting expected_setting =
423        allowed ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
424  EXPECT_EQ(expected_setting,
425            usages_state.state_map().find(requesting_origin)->second);
426}
427
428void GeolocationBrowserTest::CheckStringValueFromJavascriptForTab(
429    const std::string& expected,
430    const std::string& function,
431    WebContents* web_contents) {
432  std::string script(base::StringPrintf(
433      "window.domAutomationController.send(%s)", function.c_str()));
434  std::string result;
435  ASSERT_TRUE(content::ExecuteScriptInFrameAndExtractString(
436      web_contents, iframe_xpath_, script, &result));
437  EXPECT_EQ(expected, result);
438}
439
440void GeolocationBrowserTest::CheckStringValueFromJavascript(
441    const std::string& expected,
442    const std::string& function) {
443  CheckStringValueFromJavascriptForTab(
444      expected, function,
445      current_browser_->tab_strip_model()->GetActiveWebContents());
446}
447
448void GeolocationBrowserTest::NotifyGeoposition(double latitude,
449                                               double longitude) {
450  fake_latitude_ = latitude;
451  fake_longitude_ = longitude;
452  ui_test_utils::OverrideGeolocation(latitude, longitude);
453  LOG(WARNING) << "MockLocationProvider listeners updated";
454}
455
456
457// Tests ----------------------------------------------------------------------
458
459IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, DisplaysPermissionBar) {
460  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
461  AddGeolocationWatch(true);
462}
463
464IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, Geoposition) {
465  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
466  AddGeolocationWatch(true);
467  SetInfoBarResponse(current_url(), true);
468  CheckGeoposition(fake_latitude(), fake_longitude());
469}
470
471IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest,
472                       ErrorOnPermissionDenied) {
473  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
474  AddGeolocationWatch(true);
475  // Infobar was displayed, deny access and check for error code.
476  SetInfoBarResponse(current_url(), false);
477  CheckStringValueFromJavascript("1", "geoGetLastError()");
478}
479
480// See http://crbug.com/308358
481IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, DISABLED_NoInfobarForSecondTab) {
482  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
483  AddGeolocationWatch(true);
484  SetInfoBarResponse(current_url(), true);
485  // Disables further prompts from this tab.
486  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
487
488  // Checks infobar will not be created a second tab.
489  ASSERT_TRUE(Initialize(INITIALIZATION_NEWTAB));
490  AddGeolocationWatch(false);
491  CheckGeoposition(fake_latitude(), fake_longitude());
492}
493
494IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoInfobarForDeniedOrigin) {
495  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
496  current_browser()->profile()->GetHostContentSettingsMap()->SetContentSetting(
497      ContentSettingsPattern::FromURLNoWildcard(current_url()),
498      ContentSettingsPattern::FromURLNoWildcard(current_url()),
499      CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string(), CONTENT_SETTING_BLOCK);
500  AddGeolocationWatch(false);
501  // Checks we have an error for this denied origin.
502  CheckStringValueFromJavascript("1", "geoGetLastError()");
503  // Checks infobar will not be created a second tab.
504  ASSERT_TRUE(Initialize(INITIALIZATION_NEWTAB));
505  AddGeolocationWatch(false);
506  CheckStringValueFromJavascript("1", "geoGetLastError()");
507}
508
509IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoInfobarForAllowedOrigin) {
510  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
511  current_browser()->profile()->GetHostContentSettingsMap()->SetContentSetting(
512      ContentSettingsPattern::FromURLNoWildcard(current_url()),
513      ContentSettingsPattern::FromURLNoWildcard(current_url()),
514      CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string(), CONTENT_SETTING_ALLOW);
515  // Checks no infobar will be created and there's no error callback.
516  AddGeolocationWatch(false);
517  CheckGeoposition(fake_latitude(), fake_longitude());
518}
519
520IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoInfobarForOffTheRecord) {
521  // First, check infobar will be created for regular profile
522  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
523  AddGeolocationWatch(true);
524  // Response will be persisted
525  SetInfoBarResponse(current_url(), true);
526  CheckGeoposition(fake_latitude(), fake_longitude());
527  // Disables further prompts from this tab.
528  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
529  // Go incognito, and checks no infobar will be created.
530  ASSERT_TRUE(Initialize(INITIALIZATION_OFFTHERECORD));
531  AddGeolocationWatch(false);
532  CheckGeoposition(fake_latitude(), fake_longitude());
533}
534
535IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoLeakFromOffTheRecord) {
536  // First, check infobar will be created for incognito profile.
537  ASSERT_TRUE(Initialize(INITIALIZATION_OFFTHERECORD));
538  AddGeolocationWatch(true);
539  // Response won't be persisted.
540  SetInfoBarResponse(current_url(), true);
541  CheckGeoposition(fake_latitude(), fake_longitude());
542  // Disables further prompts from this tab.
543  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
544  // Go to the regular profile, infobar will be created.
545  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
546  AddGeolocationWatch(true);
547  SetInfoBarResponse(current_url(), false);
548  CheckStringValueFromJavascript("1", "geoGetLastError()");
549}
550
551IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, IFramesWithFreshPosition) {
552  set_html_for_tests("/geolocation/iframes_different_origin.html");
553  ASSERT_TRUE(Initialize(INITIALIZATION_IFRAMES));
554  LoadIFrames(2);
555  LOG(WARNING) << "frames loaded";
556
557  set_iframe_xpath("//iframe[@id='iframe_0']");
558  AddGeolocationWatch(true);
559  SetInfoBarResponse(iframe_url(0), true);
560  CheckGeoposition(fake_latitude(), fake_longitude());
561  // Disables further prompts from this iframe.
562  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
563
564  // Test second iframe from a different origin with a cached geoposition will
565  // create the infobar.
566  set_iframe_xpath("//iframe[@id='iframe_1']");
567  AddGeolocationWatch(true);
568
569  // Back to the first frame, enable navigation and refresh geoposition.
570  set_iframe_xpath("//iframe[@id='iframe_0']");
571  CheckStringValueFromJavascript("1", "geoSetMaxNavigateCount(1)");
572  double fresh_position_latitude = 3.17;
573  double fresh_position_longitude = 4.23;
574  content::WindowedNotificationObserver observer(
575      content::NOTIFICATION_LOAD_STOP,
576      content::Source<NavigationController>(
577          &current_browser()->tab_strip_model()->GetActiveWebContents()->
578              GetController()));
579  NotifyGeoposition(fresh_position_latitude, fresh_position_longitude);
580  observer.Wait();
581  CheckGeoposition(fresh_position_latitude, fresh_position_longitude);
582
583  // Disable navigation for this frame.
584  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
585
586  // Now go ahead an authorize the second frame.
587  set_iframe_xpath("//iframe[@id='iframe_1']");
588  // Infobar was displayed, allow access and check there's no error code.
589  SetInfoBarResponse(iframe_url(1), true);
590  LOG(WARNING) << "Checking position...";
591  CheckGeoposition(fresh_position_latitude, fresh_position_longitude);
592  LOG(WARNING) << "...done.";
593}
594
595IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest,
596                       IFramesWithCachedPosition) {
597  set_html_for_tests("/geolocation/iframes_different_origin.html");
598  ASSERT_TRUE(Initialize(INITIALIZATION_IFRAMES));
599  LoadIFrames(2);
600
601  set_iframe_xpath("//iframe[@id='iframe_0']");
602  AddGeolocationWatch(true);
603  SetInfoBarResponse(iframe_url(0), true);
604  CheckGeoposition(fake_latitude(), fake_longitude());
605
606  // Refresh geoposition, but let's not yet create the watch on the second frame
607  // so that it'll fetch from cache.
608  double cached_position_latitude = 5.67;
609  double cached_position_lognitude = 8.09;
610  content::WindowedNotificationObserver observer(
611      content::NOTIFICATION_LOAD_STOP,
612      content::Source<NavigationController>(
613          &current_browser()->tab_strip_model()->GetActiveWebContents()->
614              GetController()));
615  NotifyGeoposition(cached_position_latitude, cached_position_lognitude);
616  observer.Wait();
617  CheckGeoposition(cached_position_latitude, cached_position_lognitude);
618
619  // Disable navigation for this frame.
620  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
621
622  // Now go ahead an authorize the second frame.
623  set_iframe_xpath("//iframe[@id='iframe_1']");
624  AddGeolocationWatch(true);
625  // WebKit will use its cache, but we also broadcast a position shortly
626  // afterwards. We're only interested in the first navigation for the success
627  // callback from the cached position.
628  CheckStringValueFromJavascript("1", "geoSetMaxNavigateCount(1)");
629  SetInfoBarResponse(iframe_url(1), true);
630  CheckGeoposition(cached_position_latitude, cached_position_lognitude);
631}
632
633IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, CancelPermissionForFrame) {
634  set_html_for_tests("/geolocation/iframes_different_origin.html");
635  ASSERT_TRUE(Initialize(INITIALIZATION_IFRAMES));
636  LoadIFrames(2);
637  LOG(WARNING) << "frames loaded";
638
639  set_iframe_xpath("//iframe[@id='iframe_0']");
640  AddGeolocationWatch(true);
641  SetInfoBarResponse(iframe_url(0), true);
642  CheckGeoposition(fake_latitude(), fake_longitude());
643  // Disables further prompts from this iframe.
644  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
645
646  // Test second iframe from a different origin with a cached geoposition will
647  // create the infobar.
648  set_iframe_xpath("//iframe[@id='iframe_1']");
649  AddGeolocationWatch(true);
650
651  InfoBarService* infobar_service = InfoBarService::FromWebContents(
652      current_browser()->tab_strip_model()->GetActiveWebContents());
653  size_t num_infobars_before_cancel = infobar_service->infobar_count();
654  // Change the iframe, and ensure the infobar is gone.
655  IFrameLoader change_iframe_1(current_browser(), 1, current_url());
656  size_t num_infobars_after_cancel = infobar_service->infobar_count();
657  EXPECT_EQ(num_infobars_before_cancel, num_infobars_after_cancel + 1);
658}
659
660IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, InvalidUrlRequest) {
661  // Tests that an invalid URL (e.g. from a popup window) is rejected
662  // correctly. Also acts as a regression test for http://crbug.com/40478
663  set_html_for_tests("/geolocation/invalid_request_url.html");
664  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
665  WebContents* original_tab =
666      current_browser()->tab_strip_model()->GetActiveWebContents();
667  CheckStringValueFromJavascript("1", "requestGeolocationFromInvalidUrl()");
668  CheckStringValueFromJavascriptForTab("1", "isAlive()", original_tab);
669}
670
671IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, NoInfoBarBeforeStart) {
672  // See http://crbug.com/42789
673  set_html_for_tests("/geolocation/iframes_different_origin.html");
674  ASSERT_TRUE(Initialize(INITIALIZATION_IFRAMES));
675  LoadIFrames(2);
676  LOG(WARNING) << "frames loaded";
677
678  // Access navigator.geolocation, but ensure it won't request permission.
679  set_iframe_xpath("//iframe[@id='iframe_1']");
680  CheckStringValueFromJavascript("object", "geoAccessNavigatorGeolocation()");
681
682  set_iframe_xpath("//iframe[@id='iframe_0']");
683  AddGeolocationWatch(true);
684  SetInfoBarResponse(iframe_url(0), true);
685  CheckGeoposition(fake_latitude(), fake_longitude());
686  CheckStringValueFromJavascript("0", "geoSetMaxNavigateCount(0)");
687
688  // Permission should be requested after adding a watch.
689  set_iframe_xpath("//iframe[@id='iframe_1']");
690  AddGeolocationWatch(true);
691  SetInfoBarResponse(iframe_url(1), true);
692  CheckGeoposition(fake_latitude(), fake_longitude());
693}
694
695IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, TwoWatchesInOneFrame) {
696  set_html_for_tests("/geolocation/two_watches.html");
697  ASSERT_TRUE(Initialize(INITIALIZATION_NONE));
698  // First, set the JavaScript to navigate when it receives |final_position|.
699  double final_position_latitude = 3.17;
700  double final_position_longitude = 4.23;
701  std::string script = base::StringPrintf(
702      "window.domAutomationController.send(geoSetFinalPosition(%f, %f))",
703      final_position_latitude, final_position_longitude);
704  std::string js_result;
705  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
706      current_browser()->tab_strip_model()->GetActiveWebContents(), script,
707      &js_result));
708  EXPECT_EQ(js_result, "ok");
709
710  // Send a position which both geolocation watches will receive.
711  AddGeolocationWatch(true);
712  SetInfoBarResponse(current_url(), true);
713  CheckGeoposition(fake_latitude(), fake_longitude());
714
715  // The second watch will now have cancelled. Ensure an update still makes
716  // its way through to the first watcher.
717  content::WindowedNotificationObserver observer(
718      content::NOTIFICATION_LOAD_STOP,
719      content::Source<NavigationController>(
720          &current_browser()->tab_strip_model()->GetActiveWebContents()->
721              GetController()));
722  NotifyGeoposition(final_position_latitude, final_position_longitude);
723  observer.Wait();
724  CheckGeoposition(final_position_latitude, final_position_longitude);
725}
726
727IN_PROC_BROWSER_TEST_F(GeolocationBrowserTest, TabDestroyed) {
728  set_html_for_tests("/geolocation/tab_destroyed.html");
729  ASSERT_TRUE(Initialize(INITIALIZATION_IFRAMES));
730  LoadIFrames(3);
731
732  set_iframe_xpath("//iframe[@id='iframe_0']");
733  AddGeolocationWatch(true);
734
735  set_iframe_xpath("//iframe[@id='iframe_1']");
736  AddGeolocationWatch(false);
737
738  set_iframe_xpath("//iframe[@id='iframe_2']");
739  AddGeolocationWatch(false);
740
741  std::string script =
742      "window.domAutomationController.send(window.close());";
743  bool result = content::ExecuteScript(
744      current_browser()->tab_strip_model()->GetActiveWebContents(), script);
745  EXPECT_EQ(result, true);
746}
747