Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(203)

Side by Side Diff: chrome/browser/extensions/api/tabs/tabs_test.cc

Issue 301733006: Zoom Extension API (chrome) (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Address comments. Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 5
6 #include <string> 6 #include <string>
7 7
8 #include "base/memory/ref_counted.h" 8 #include "base/memory/ref_counted.h"
9 #include "base/memory/scoped_ptr.h" 9 #include "base/memory/scoped_ptr.h"
10 #include "base/prefs/pref_service.h" 10 #include "base/prefs/pref_service.h"
11 #include "base/strings/string_util.h" 11 #include "base/strings/string_util.h"
12 #include "base/strings/stringprintf.h" 12 #include "base/strings/stringprintf.h"
13 #include "base/values.h" 13 #include "base/values.h"
14 #include "chrome/browser/extensions/api/tabs/tabs_api.h" 14 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
15 #include "chrome/browser/extensions/api/tabs/tabs_constants.h" 15 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
16 #include "chrome/browser/extensions/extension_function_test_utils.h" 16 #include "chrome/browser/extensions/extension_function_test_utils.h"
17 #include "chrome/browser/extensions/extension_tab_util.h" 17 #include "chrome/browser/extensions/extension_tab_util.h"
18 #include "chrome/browser/prefs/incognito_mode_prefs.h" 18 #include "chrome/browser/prefs/incognito_mode_prefs.h"
19 #include "chrome/browser/profiles/profile.h" 19 #include "chrome/browser/profiles/profile.h"
20 #include "chrome/browser/ui/browser.h" 20 #include "chrome/browser/ui/browser.h"
21 #include "chrome/browser/ui/browser_commands.h" 21 #include "chrome/browser/ui/browser_commands.h"
22 #include "chrome/browser/ui/browser_window.h" 22 #include "chrome/browser/ui/browser_window.h"
23 #include "chrome/browser/ui/tabs/tab_strip_model.h"
23 #include "chrome/test/base/in_process_browser_test.h" 24 #include "chrome/test/base/in_process_browser_test.h"
24 #include "chrome/test/base/ui_test_utils.h" 25 #include "chrome/test/base/ui_test_utils.h"
26 #include "content/public/common/page_zoom.h"
25 #include "content/public/common/url_constants.h" 27 #include "content/public/common/url_constants.h"
26 #include "ui/gfx/rect.h" 28 #include "ui/gfx/rect.h"
27 29
28 namespace extensions { 30 namespace extensions {
29 31
30 namespace keys = tabs_constants; 32 namespace keys = tabs_constants;
31 namespace utils = extension_function_test_utils; 33 namespace utils = extension_function_test_utils;
32 34
33 namespace { 35 namespace {
34 36
(...skipping 549 matching lines...) Expand 10 before | Expand all | Expand 10 after
584 EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType()); 586 EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType());
585 // Duplicate tab id should be different from the original tab id. 587 // Duplicate tab id should be different from the original tab id.
586 EXPECT_NE(tab_id, duplicate_tab_id); 588 EXPECT_NE(tab_id, duplicate_tab_id);
587 EXPECT_EQ(window_id, duplicate_tab_window_id); 589 EXPECT_EQ(window_id, duplicate_tab_window_id);
588 EXPECT_EQ(tab_index + 1, duplicate_tab_index); 590 EXPECT_EQ(tab_index + 1, duplicate_tab_index);
589 // The test empty extension has no permissions, therefore |duplicate_result| 591 // The test empty extension has no permissions, therefore |duplicate_result|
590 // should not contain url, title, and faviconUrl in the function result. 592 // should not contain url, title, and faviconUrl in the function result.
591 EXPECT_FALSE(utils::HasPrivacySensitiveFields(duplicate_result.get())); 593 EXPECT_FALSE(utils::HasPrivacySensitiveFields(duplicate_result.get()));
592 } 594 }
593 595
596 // Tester class for the tabs.zoom* api functions.
597 class ExtensionTabsZoomTest : public ExtensionTabsTest {
598 public:
599 virtual void SetUpOnMainThread() OVERRIDE;
600
601 // Runs chrome.tabs.setZoom().
602 bool RunSetZoom(int tab_id, double zoom_factor);
603
604 // Runs chrome.tabs.getZoom().
605 testing::AssertionResult RunGetZoom(int tab_id, double* zoom_factor);
606
607 // Runs chrome.tabs.setZoomSettings().
608 bool RunSetZoomSettings(int tab_id, const char* mode, const char* scope);
609
610 // Runs chrome.tabs.getZoomSettings().
611 testing::AssertionResult RunGetZoomSettings(int tab_id,
612 std::string* mode,
613 std::string* scope);
614
615 // Runs chrome.tabs.setZoom(), expecting an error.
616 std::string RunSetZoomExpectError(int tab_id,
617 double zoom_factor);
618
619 // Runs chrome.tabs.setZoomSettings(), expecting an error.
620 std::string RunSetZoomSettingsExpectError(int tab_id,
621 const char* mode,
622 const char* scope);
623
624 content::WebContents* OpenUrlAndWaitForLoad(const GURL& url);
625
626 private:
627 scoped_refptr<Extension> extension_;
628 };
629
630 void ExtensionTabsZoomTest::SetUpOnMainThread() {
631 ExtensionTabsTest::SetUpOnMainThread();
632 extension_ = utils::CreateEmptyExtension();
633 }
634
635 bool ExtensionTabsZoomTest::RunSetZoom(int tab_id, double zoom_factor) {
636 scoped_refptr<TabsSetZoomFunction> set_zoom_function(
637 new TabsSetZoomFunction());
638 set_zoom_function->set_extension(extension_);
639 set_zoom_function->set_has_callback(true);
640
641 return utils::RunFunction(
642 set_zoom_function.get(),
643 base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
644 browser(),
645 extension_function_test_utils::NONE);
646 }
647
648 testing::AssertionResult ExtensionTabsZoomTest::RunGetZoom(
649 int tab_id,
650 double* zoom_factor) {
651 scoped_refptr<TabsGetZoomFunction> get_zoom_function(
652 new TabsGetZoomFunction());
653 get_zoom_function->set_extension(extension_);
654 get_zoom_function->set_has_callback(true);
655
656 scoped_ptr<base::Value> get_zoom_result(
657 utils::RunFunctionAndReturnSingleResult(
658 get_zoom_function.get(),
659 base::StringPrintf("[%u]", tab_id),
660 browser()));
661
662 if (!get_zoom_result)
663 return testing::AssertionFailure() << "no result";
664 if (!get_zoom_result->GetAsDouble(zoom_factor))
665 return testing::AssertionFailure() << "result was not a double";
666
667 return testing::AssertionSuccess();
668 }
669
670 bool ExtensionTabsZoomTest::RunSetZoomSettings(int tab_id,
671 const char* mode,
672 const char* scope) {
673 scoped_refptr<TabsSetZoomSettingsFunction> set_zoom_settings_function(
674 new TabsSetZoomSettingsFunction());
675 set_zoom_settings_function->set_extension(extension_);
676
677 std::string args;
678 if (scope) {
679 args = base::StringPrintf("[%u, {\"mode\": \"%s\", \"scope\": \"%s\"}]",
680 tab_id, mode, scope);
681 } else {
682 args = base::StringPrintf("[%u, {\"mode\": \"%s\"}]", tab_id, mode);
683 }
684
685 return utils::RunFunction(set_zoom_settings_function.get(),
686 args,
687 browser(),
688 extension_function_test_utils::NONE);
689 }
690
691 testing::AssertionResult ExtensionTabsZoomTest::RunGetZoomSettings(
692 int tab_id,
693 std::string* mode,
694 std::string* scope) {
695 DCHECK(mode);
696 DCHECK(scope);
697 scoped_refptr<TabsGetZoomSettingsFunction> get_zoom_settings_function(
698 new TabsGetZoomSettingsFunction());
699 get_zoom_settings_function->set_extension(extension_);
700 get_zoom_settings_function->set_has_callback(true);
701
702 scoped_ptr<base::DictionaryValue> get_zoom_settings_result(
703 utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
704 get_zoom_settings_function.get(),
705 base::StringPrintf("[%u]", tab_id),
706 browser())));
707
708 if (!get_zoom_settings_result)
709 return testing::AssertionFailure() << "no result";
710
711 *mode = utils::GetString(get_zoom_settings_result.get(), "mode");
712 *scope = utils::GetString(get_zoom_settings_result.get(), "scope");
713
714 return testing::AssertionSuccess();
715 }
716
717 std::string ExtensionTabsZoomTest::RunSetZoomExpectError(int tab_id,
718 double zoom_factor) {
719 scoped_refptr<TabsSetZoomFunction> set_zoom_function(
720 new TabsSetZoomFunction());
721 set_zoom_function->set_extension(extension_);
722 set_zoom_function->set_has_callback(true);
723
724 return utils::RunFunctionAndReturnError(
725 set_zoom_function.get(),
726 base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
727 browser());
728 }
729
730 std::string ExtensionTabsZoomTest::RunSetZoomSettingsExpectError(
731 int tab_id,
732 const char* mode,
733 const char* scope) {
734 scoped_refptr<TabsSetZoomSettingsFunction> set_zoom_settings_function(
735 new TabsSetZoomSettingsFunction());
736 set_zoom_settings_function->set_extension(extension_);
737
738 return utils::RunFunctionAndReturnError(set_zoom_settings_function.get(),
739 base::StringPrintf(
740 "[%u, {\"mode\": \"%s\", "
741 "\"scope\": \"%s\"}]",
742 tab_id,
743 mode,
744 scope),
745 browser());
746 }
747
748 content::WebContents* ExtensionTabsZoomTest::OpenUrlAndWaitForLoad(
749 const GURL& url) {
750 ui_test_utils::NavigateToURLWithDisposition(
751 browser(),
752 url,
753 NEW_FOREGROUND_TAB,
754 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
755 return browser()->tab_strip_model()->GetActiveWebContents();
756 }
757
758 namespace {
759
760 double GetZoomLevel(const content::WebContents* web_contents) {
761 return ZoomController::FromWebContents(web_contents)->GetZoomLevel();
762 }
763
764 content::OpenURLParams GetOpenParams(const char* url) {
765 return content::OpenURLParams(GURL(url),
766 content::Referrer(),
767 NEW_FOREGROUND_TAB,
768 content::PAGE_TRANSITION_LINK,
769 false);
770 }
771
772 } // namespace
773
774 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, SetAndGetZoom) {
775 content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
776 content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
777 int tab_id = ExtensionTabUtil::GetTabId(web_contents);
778
779 // Test default values before we set anything.
780 double zoom_factor = -1;
781 EXPECT_TRUE(RunGetZoom(tab_id, &zoom_factor));
782 EXPECT_EQ(1.0, zoom_factor);
783
784 // Test chrome.tabs.setZoom().
785 const double kZoomLevel = 0.8;
786 EXPECT_TRUE(RunSetZoom(tab_id, kZoomLevel));
787 EXPECT_EQ(kZoomLevel,
788 content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents)));
789
790 // Test chrome.tabs.getZoom().
791 zoom_factor = -1;
792 EXPECT_TRUE(RunGetZoom(tab_id, &zoom_factor));
793 EXPECT_EQ(kZoomLevel, zoom_factor);
794 }
795
796 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, ZoomSettings) {
797 const char kNewTestTabArgsA[] = "data:text/html,A";
798 const char kNewTestTabArgsB[] = "data:text/html,B";
799
800 content::OpenURLParams params_A(GetOpenParams(kNewTestTabArgsA));
801 content::OpenURLParams params_B(GetOpenParams(kNewTestTabArgsB));
802
803 // Tabs A1 and A2 are navigated to the same origin, while B is navigated
804 // to a different one.
805 content::WebContents* web_contents_A1 = OpenUrlAndWaitForLoad(params_A.url);
806 content::WebContents* web_contents_A2 = OpenUrlAndWaitForLoad(params_A.url);
807 content::WebContents* web_contents_B = OpenUrlAndWaitForLoad(params_B.url);
808
809 int tab_id_A1 = ExtensionTabUtil::GetTabId(web_contents_A1);
810 int tab_id_A2 = ExtensionTabUtil::GetTabId(web_contents_A2);
811 int tab_id_B = ExtensionTabUtil::GetTabId(web_contents_B);
812
813 ASSERT_FLOAT_EQ(
814 1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
815 ASSERT_FLOAT_EQ(
816 1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
817 ASSERT_FLOAT_EQ(
818 1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_B)));
819
820 // Test per-origin automatic zoom settings.
821 EXPECT_TRUE(RunSetZoom(tab_id_B, 1.f));
822 EXPECT_TRUE(RunSetZoom(tab_id_A2, 1.1f));
823 EXPECT_FLOAT_EQ(
824 1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
825 EXPECT_FLOAT_EQ(
826 1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
827 EXPECT_FLOAT_EQ(1.f,
828 content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_B)));
829
830 // Test per-tab automatic zoom settings.
831 EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "automatic", "per-tab"));
832 EXPECT_TRUE(RunSetZoom(tab_id_A1, 1.2f));
833 EXPECT_FLOAT_EQ(
834 1.2f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
835 EXPECT_FLOAT_EQ(
836 1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
837
838 // Test 'manual' mode.
839 EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "manual", NULL));
840 EXPECT_TRUE(RunSetZoom(tab_id_A1, 1.3f));
841 EXPECT_FLOAT_EQ(
842 1.3f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
843 EXPECT_FLOAT_EQ(
844 1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
845
846 // Test 'disabled' mode, which will reset A1's zoom to 1.f.
847 EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "disabled", NULL));
848 std::string error = RunSetZoomExpectError(tab_id_A1, 1.4f);
849 EXPECT_TRUE(MatchPattern(error, keys::kCannotZoomDisabledTabError));
850 EXPECT_FLOAT_EQ(
851 1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
852 // We should still be able to zoom A2 though.
853 EXPECT_TRUE(RunSetZoom(tab_id_A2, 1.4f));
854 EXPECT_FLOAT_EQ(
855 1.4f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
856 }
857
858 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, GetZoomSettings) {
859 content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
860 content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
861 int tab_id = ExtensionTabUtil::GetTabId(web_contents);
862
863 std::string mode;
864 std::string scope;
865
866 EXPECT_TRUE(RunGetZoomSettings(tab_id, &mode, &scope));
867 EXPECT_EQ("automatic", mode);
868 EXPECT_EQ("per-origin", scope);
869
870 EXPECT_TRUE(RunSetZoomSettings(tab_id, "automatic", "per-tab"));
871 EXPECT_TRUE(RunGetZoomSettings(tab_id, &mode, &scope));
872
873 EXPECT_EQ("automatic", mode);
874 EXPECT_EQ("per-tab", scope);
875
876 std::string error =
877 RunSetZoomSettingsExpectError(tab_id, "manual", "per-origin");
878 EXPECT_TRUE(MatchPattern(error,
879 keys::kPerOriginOnlyInAutomaticError));
880 error =
881 RunSetZoomSettingsExpectError(tab_id, "disabled", "per-origin");
882 EXPECT_TRUE(MatchPattern(error,
883 keys::kPerOriginOnlyInAutomaticError));
884 }
885
886 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, CannotZoomInvalidTab) {
887 content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
888 content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
889 int tab_id = ExtensionTabUtil::GetTabId(web_contents);
890
891 int bogus_id = tab_id + 100;
892 std::string error = RunSetZoomExpectError(bogus_id, 3.14159);
893 EXPECT_TRUE(MatchPattern(error, keys::kTabNotFoundError));
894
895 error = RunSetZoomSettingsExpectError(bogus_id, "manual", "per-tab");
896 EXPECT_TRUE(MatchPattern(error, keys::kTabNotFoundError));
897
898 const char kNewTestTabArgs[] = "chrome://version";
899 params = GetOpenParams(kNewTestTabArgs);
900 web_contents = browser()->OpenURL(params);
901 tab_id = ExtensionTabUtil::GetTabId(web_contents);
902
903 // Test chrome.tabs.setZoom().
904 error = RunSetZoomExpectError(tab_id, 3.14159);
905 EXPECT_TRUE(MatchPattern(error, keys::kCannotZoomChromePagesError));
906
907 // chrome.tabs.setZoomSettings().
908 error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
909 EXPECT_TRUE(MatchPattern(error,
910 keys::kCannotChangeChromePageZoomSettingsError));
911 }
912
594 } // namespace extensions 913 } // namespace extensions
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698