Data page

element, // and move the input focus to the

element, where we can use // IMEs. LoadHTML( "" "" "" "" "

" "" ""); ExecuteJavaScriptForTests("document.getElementById('test1').focus();"); break; case IME_SETINPUTMODE: break; case IME_SETFOCUS: // Update the window focus. GetWidgetInputHandler()->SetFocus( ime_message->enable ? blink::mojom::FocusState::kFocused : blink::mojom::FocusState::kNotFocusedAndActive); break; case IME_SETCOMPOSITION: GetWidgetInputHandler()->ImeSetComposition( base::WideToUTF16(ime_message->ime_string), std::vector(), gfx::Range::InvalidRange(), ime_message->selection_start, ime_message->selection_end, base::DoNothing()); break; case IME_COMMITTEXT: GetWidgetInputHandler()->ImeCommitText( base::WideToUTF16(ime_message->ime_string), std::vector(), gfx::Range::InvalidRange(), 0, base::DoNothing()); break; case IME_FINISHCOMPOSINGTEXT: GetWidgetInputHandler()->ImeFinishComposingText(false); break; case IME_CANCELCOMPOSITION: GetWidgetInputHandler()->ImeSetComposition( std::u16string(), std::vector(), gfx::Range::InvalidRange(), 0, 0, base::DoNothing()); break; } // Update the status of our IME back-end. // TODO(hbono): we should verify messages to be sent from the back-end. main_frame_widget()->UpdateTextInputState(); base::RunLoop().RunUntilIdle(); render_thread_->sink().ClearMessages(); if (ime_message->result) { // Retrieve the content of this page and compare it with the expected // result. const int kMaxOutputCharacters = 128; std::u16string output = TestWebFrameContentDumper::DumpWebViewAsText( web_view_, kMaxOutputCharacters) .Utf16(); EXPECT_EQ(base::WideToUTF16(ime_message->result), output); } } } // Test that the RenderView::OnSetTextDirection() function can change the text // direction of the selected input element. TEST_F(RenderViewImplTest, OnSetTextDirection) { // Load an HTML page consisting of a " "

" "" ""); render_thread_->sink().ClearMessages(); static const struct { base::i18n::TextDirection direction; const wchar_t* expected_result; } kTextDirection[] = { {base::i18n::TextDirection::RIGHT_TO_LEFT, L"rtl,rtl"}, {base::i18n::TextDirection::LEFT_TO_RIGHT, L"ltr,ltr"}, }; for (auto& test_case : kTextDirection) { // Set the text direction of the

element.
    ExecuteJavaScriptForTests("document.getElementById('test').focus();");
    GetMainFrame()->SetTextDirectionForTesting(test_case.direction);

// Write the values of its DOM 'dir' attribute and its CSS 'direction'
    // property to the <div> element.
    ExecuteJavaScriptForTests(
        "var result = document.getElementById('result');"
        "var node = document.getElementById('test');"
        "var style = getComputedStyle(node, null);"
        "result.innerText ="
        "    node.getAttribute('dir') + ',' +"
        "    style.getPropertyValue('direction');");

// Copy the document content to std::wstring and compare with the
    // expected result.
    const int kMaxOutputCharacters = 16;
    std::u16string output = TestWebFrameContentDumper::DumpWebViewAsText(
                                web_view_, kMaxOutputCharacters)
                                .Utf16();
    EXPECT_EQ(base::WideToUTF16(test_case.expected_result), output);
  }
}

TEST_F(RenderViewImplTest, DroppedNavigationStaysInViewSourceMode) {
  GetMainFrame()->EnableViewSourceMode(true);
  WebURLError error(net::ERR_ABORTED, GURL("http://foo"));
  WebLocalFrame* web_frame = GetMainFrame();

// Start a load that will reach provisional state synchronously,
  // but won't complete synchronously.
  auto common_params = blink::CreateCommonNavigationParams();
  common_params->navigation_type =
      blink::mojom::NavigationType::DIFFERENT_DOCUMENT;
  common_params->url = GURL("data:text/html,test data");
  frame()->Navigate(std::move(common_params), DummyCommitNavigationParams());

// A cancellation occurred.
  frame()->OnDroppedNavigation();
  // Frame should stay in view-source mode.
  EXPECT_TRUE(web_frame->IsViewSourceModeEnabled());
}

namespace {

class ContextMenuFrameHost : public LocalFrameHostInterceptor {
 public:
  explicit ContextMenuFrameHost(blink::AssociatedInterfaceProvider* provider)
      : LocalFrameHostInterceptor(provider) {}

MOCK_METHOD2(
      ShowContextMenu,
      void(
          mojo::PendingAssociatedRemote<blink::mojom::ContextMenuClient> client,
          const blink::UntrustworthyContextMenuParams& params));
};

}  // namespace

class RenderViewImplContextMenuTest : public RenderViewImplTest {
 public:
  using MockedTestRenderFrame =
      MockedLocalFrameHostInterceptorTestRenderFrame<ContextMenuFrameHost>;

RenderViewImplContextMenuTest()
      : RenderViewImplTest(&MockedTestRenderFrame::CreateTestRenderFrame) {}

ContextMenuFrameHost* context_menu_frame_host() {
    return static_cast<MockedTestRenderFrame*>(frame())
        ->mock_local_frame_host();
  }
};

#if !BUILDFLAG(IS_ANDROID)
TEST_F(RenderViewImplContextMenuTest, ContextMenu) {
  LoadHTML("<div>Page A</div>");

// Create a right click in the center of the iframe. (I'm hoping this will
  // make this a bit more robust in case of some other formatting or other
  // bug.)
  WebMouseEvent mouse_event(WebInputEvent::Type::kMouseDown,
                            WebInputEvent::kNoModifiers, ui::EventTimeForNow());
  mouse_event.button = WebMouseEvent::Button::kRight;
  mouse_event.SetPositionInWidget(250, 250);
  mouse_event.SetPositionInScreen(250, 250);

SendWebMouseEvent(mouse_event);

// Now simulate the corresponding up event which should display the menu
  mouse_event.SetType(WebInputEvent::Type::kMouseUp);
  SendWebMouseEvent(mouse_event);

EXPECT_CALL(*context_menu_frame_host(),
              ShowContextMenu(testing::_, testing::_))
      .Times(1);
}

#else
TEST_F(RenderViewImplContextMenuTest, AndroidContextMenuSelectionOrdering) {
  LoadHTML("<div>Page A</div><div id=result>Not selected</div>");

ExecuteJavaScriptForTests(
      "document.onselectionchange = function() { "
      "document.getElementById('result').innerHTML = 'Selected'}");

// Create a long press in the center of the iframe. (I'm hoping this will
  // make this a bit more robust in case of some other formatting or other bug.)
  WebGestureEvent gesture_event(WebInputEvent::Type::kGestureLongPress,
                                WebInputEvent::kNoModifiers,
                                ui::EventTimeForNow());
  gesture_event.SetPositionInWidget(gfx::PointF(250, 250));

EXPECT_CALL(*context_menu_frame_host(),
              ShowContextMenu(testing::_, testing::_))
      .Times(0);

SendWebGestureEvent(gesture_event);

EXPECT_CALL(*context_menu_frame_host(),
              ShowContextMenu(testing::_, testing::_))
      .Times(1);

scoped_refptr<content::MessageLoopRunner> message_loop_runner =
      new content::MessageLoopRunner;
  blink::scheduler::GetSingleThreadTaskRunnerForTesting()->PostTask(
      FROM_HERE, message_loop_runner->QuitClosure());

message_loop_runner->Run();

int did_select = -1;
  std::u16string check_did_select =
      u"Number(document.getElementById('result').innerHTML == 'Selected')";
  EXPECT_TRUE(
      ExecuteJavaScriptAndReturnIntValue(check_did_select, &did_select));
  EXPECT_EQ(1, did_select);
}
#endif

TEST_F(RenderViewImplTest, TestBackForward) {
  LoadHTML("<div id=pagename>Page A</div>");
  blink::PageState page_a_state = GetCurrentPageState();
  int was_page_a = -1;
  std::u16string check_page_a =
      u"Number(document.getElementById('pagename').innerHTML == 'Page A')";
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_a, &was_page_a));
  EXPECT_EQ(1, was_page_a);

LoadHTML("<div id=pagename>Page B</div>");
  int was_page_b = -1;
  std::u16string check_page_b =
      u"Number(document.getElementById('pagename').innerHTML == 'Page B')";
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
  EXPECT_EQ(1, was_page_b);

blink::PageState back_state = GetCurrentPageState();

LoadHTML("<div id=pagename>Page C</div>");
  int was_page_c = -1;
  std::u16string check_page_c =
      u"Number(document.getElementById('pagename').innerHTML == 'Page C')";
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_c, &was_page_c));
  EXPECT_EQ(1, was_page_c);

blink::PageState forward_state = GetCurrentPageState();

// Go back.
  GoBack(GURL("data:text/html;charset=utf-8,<div id=pagename>Page B</div>"),
         back_state);

EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
  EXPECT_EQ(1, was_page_b);
  blink::PageState back_state2 = GetCurrentPageState();

// Go forward.
  GoForward(GURL("data:text/html;charset=utf-8,<div id=pagename>Page C</div>"),
            forward_state);
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_c, &was_page_c));
  EXPECT_EQ(1, was_page_c);

// Go back.
  GoBack(GURL("data:text/html;charset=utf-8,<div id=pagename>Page B</div>"),
         back_state2);
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
  EXPECT_EQ(1, was_page_b);

forward_state = GetCurrentPageState();

// Go back.
  GoBack(GURL("data:text/html;charset=utf-8,<div id=pagename>Page A</div>"),
         page_a_state);
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_a, &was_page_a));
  EXPECT_EQ(1, was_page_a);

// Go forward.
  GoForward(GURL("data:text/html;charset=utf-8,<div id=pagename>Page B</div>"),
            forward_state);
  EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
  EXPECT_EQ(1, was_page_b);
}

#if BUILDFLAG(IS_MAC) || defined(USE_AURA)
TEST_F(RenderViewImplTest, GetCompositionCharacterBoundsTest) {
  LoadHTML("<textarea id=\"test\" cols=\"100\">

"); ExecuteJavaScriptForTests("document.getElementById('test').focus();"); auto* widget_input_handler = GetWidgetInputHandler(); const std::u16string empty_string; const std::vector empty_ime_text_span; std::vector bounds; widget_input_handler->SetFocus(blink::mojom::FocusState::kFocused); // ASCII composition const std::u16string ascii_composition = u"aiueo"; widget_input_handler->ImeSetComposition( ascii_composition, empty_ime_text_span, gfx::Range::InvalidRange(), 0, 0, base::DoNothing()); bounds = LastCompositionBounds(); ASSERT_EQ(ascii_composition.size(), bounds.size()); for (const gfx::Rect& r : bounds) EXPECT_LT(0, r.width()); widget_input_handler->ImeCommitText( empty_string, std::vector(), gfx::Range::InvalidRange(), 0, base::DoNothing()); // Non surrogate pair unicode character. const std::u16string unicode_composition = u"あいうえお"; widget_input_handler->ImeSetComposition( unicode_composition, empty_ime_text_span, gfx::Range::InvalidRange(), 0, 0, base::DoNothing()); bounds = LastCompositionBounds(); ASSERT_EQ(unicode_composition.size(), bounds.size()); for (const gfx::Rect& r : bounds) EXPECT_LT(0, r.width()); widget_input_handler->ImeCommitText(empty_string, empty_ime_text_span, gfx::Range::InvalidRange(), 0, base::DoNothing()); // Surrogate pair character. const std::u16string surrogate_pair_char = u"𠮟"; widget_input_handler->ImeSetComposition( surrogate_pair_char, empty_ime_text_span, gfx::Range::InvalidRange(), 0, 0, base::DoNothing()); bounds = LastCompositionBounds(); ASSERT_EQ(surrogate_pair_char.size(), bounds.size()); EXPECT_LT(0, bounds[0].width()); EXPECT_EQ(0, bounds[1].width()); widget_input_handler->ImeCommitText(empty_string, empty_ime_text_span, gfx::Range::InvalidRange(), 0, base::DoNothing()); // Mixed string. const std::u16string surrogate_pair_mixed_composition = surrogate_pair_char + u"あ" + surrogate_pair_char + u"b" + surrogate_pair_char; const size_t utf16_length = 8UL; const bool is_surrogate_pair_empty_rect[8] = {false, true, false, false, true, false, false, true}; widget_input_handler->ImeSetComposition( surrogate_pair_mixed_composition, empty_ime_text_span, gfx::Range::InvalidRange(), 0, 0, base::DoNothing()); bounds = LastCompositionBounds(); ASSERT_EQ(utf16_length, bounds.size()); for (size_t i = 0; i < utf16_length; ++i) { if (is_surrogate_pair_empty_rect[i]) { EXPECT_EQ(0, bounds[i].width()); } else { EXPECT_LT(0, bounds[i].width()); } } widget_input_handler->ImeCommitText(empty_string, empty_ime_text_span, gfx::Range::InvalidRange(), 0, base::DoNothing()); } #endif TEST_F(RenderViewImplTest, SetEditableSelectionAndComposition) { // Load an HTML page consisting of an input field. LoadHTML( "" "" "" "" "" "" ""); auto* frame_widget_input_handler = GetFrameWidgetInputHandler(); ExecuteJavaScriptForTests("document.getElementById('test1').focus();"); frame_widget_input_handler->SetEditableSelectionOffsets(4, 8); const std::vector empty_ime_text_span; frame_widget_input_handler->SetCompositionFromExistingText( 7, 10, empty_ime_text_span); base::RunLoop().RunUntilIdle(); blink::WebInputMethodController* controller = frame()->GetWebFrame()->GetInputMethodController(); blink::WebTextInputInfo info = controller->TextInputInfo(); EXPECT_EQ(4, info.selection_start); EXPECT_EQ(8, info.selection_end); EXPECT_EQ(7, info.composition_start); EXPECT_EQ(10, info.composition_end); frame_widget_input_handler->CollapseSelection(); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ(8, info.selection_start); EXPECT_EQ(8, info.selection_end); } TEST_F(RenderViewImplTest, OnExtendSelectionAndDelete) { // Load an HTML page consisting of an input field. LoadHTML( "" "" "" "" "" "" ""); auto* frame_widget_input_handler = GetFrameWidgetInputHandler(); ExecuteJavaScriptForTests("document.getElementById('test1').focus();"); frame_widget_input_handler->SetEditableSelectionOffsets(10, 10); frame_widget_input_handler->ExtendSelectionAndDelete(3, 4); base::RunLoop().RunUntilIdle(); blink::WebInputMethodController* controller = frame()->GetWebFrame()->GetInputMethodController(); blink::WebTextInputInfo info = controller->TextInputInfo(); EXPECT_EQ("abcdefgopqrstuvwxyz", info.value); EXPECT_EQ(7, info.selection_start); EXPECT_EQ(7, info.selection_end); frame_widget_input_handler->SetEditableSelectionOffsets(4, 8); frame_widget_input_handler->ExtendSelectionAndDelete(2, 5); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ("abuvwxyz", info.value); EXPECT_EQ(2, info.selection_start); EXPECT_EQ(2, info.selection_end); } TEST_F(RenderViewImplTest, OnDeleteSurroundingText) { // Load an HTML page consisting of an input field. LoadHTML( "" "" "" "" "" "" ""); ExecuteJavaScriptForTests("document.getElementById('test1').focus();"); auto* frame_widget_input_handler = GetFrameWidgetInputHandler(); frame_widget_input_handler->SetEditableSelectionOffsets(10, 10); frame_widget_input_handler->DeleteSurroundingText(3, 4); base::RunLoop().RunUntilIdle(); blink::WebInputMethodController* controller = frame()->GetWebFrame()->GetInputMethodController(); blink::WebTextInputInfo info = controller->TextInputInfo(); EXPECT_EQ("abcdefgopqrstuvwxyz", info.value); EXPECT_EQ(7, info.selection_start); EXPECT_EQ(7, info.selection_end); frame_widget_input_handler->SetEditableSelectionOffsets(4, 8); frame_widget_input_handler->DeleteSurroundingText(2, 5); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ("abefgouvwxyz", info.value); EXPECT_EQ(2, info.selection_start); EXPECT_EQ(6, info.selection_end); frame_widget_input_handler->SetEditableSelectionOffsets(5, 5); frame_widget_input_handler->DeleteSurroundingText(10, 0); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ("ouvwxyz", info.value); EXPECT_EQ(0, info.selection_start); EXPECT_EQ(0, info.selection_end); frame_widget_input_handler->DeleteSurroundingText(0, 10); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ("", info.value); EXPECT_EQ(0, info.selection_start); EXPECT_EQ(0, info.selection_end); frame_widget_input_handler->DeleteSurroundingText(10, 10); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ("", info.value); EXPECT_EQ(0, info.selection_start); EXPECT_EQ(0, info.selection_end); } #if BUILDFLAG(IS_ANDROID) // Failing on Android M: http://crbug.com/873580 #define MAYBE_OnDeleteSurroundingTextInCodePoints \ DISABLED_OnDeleteSurroundingTextInCodePoints #else #define MAYBE_OnDeleteSurroundingTextInCodePoints \ OnDeleteSurroundingTextInCodePoints #endif TEST_F(RenderViewImplTest, MAYBE_OnDeleteSurroundingTextInCodePoints) { // Load an HTML page consisting of an input field. LoadHTML( // "ab" + trophy + space + "cdef" + trophy + space + "gh". ""); ExecuteJavaScriptForTests("document.getElementById('test1').focus();"); auto* frame_widget_input_handler = GetFrameWidgetInputHandler(); frame_widget_input_handler->SetEditableSelectionOffsets(4, 4); frame_widget_input_handler->DeleteSurroundingTextInCodePoints(2, 2); base::RunLoop().RunUntilIdle(); blink::WebInputMethodController* controller = frame()->GetWebFrame()->GetInputMethodController(); blink::WebTextInputInfo info = controller->TextInputInfo(); // "a" + "def" + trophy + space + "gh". EXPECT_EQ(WebString::FromUTF8("adef\xF0\x9F\x8F\x86 gh"), info.value); EXPECT_EQ(1, info.selection_start); EXPECT_EQ(1, info.selection_end); frame_widget_input_handler->SetEditableSelectionOffsets(1, 3); frame_widget_input_handler->DeleteSurroundingTextInCodePoints(1, 4); base::RunLoop().RunUntilIdle(); info = controller->TextInputInfo(); EXPECT_EQ("deh", info.value); EXPECT_EQ(0, info.selection_start); EXPECT_EQ(2, info.selection_end); } // Test that the navigating specific frames works correctly. TEST_F(RenderViewImplTest, NavigateSubframe) { // Load page A. LoadHTML("hello "); // Navigate the frame only. auto common_params = blink::CreateCommonNavigationParams(); common_params->url = GURL("data:text/html,world"); common_params->navigation_type = blink::mojom::NavigationType::DIFFERENT_DOCUMENT; common_params->transition = ui::PAGE_TRANSITION_TYPED; common_params->navigation_start = base::TimeTicks::Now(); auto commit_params = DummyCommitNavigationParams(); commit_params->current_history_list_length = 1; commit_params->current_history_list_offset = 0; commit_params->pending_history_list_offset = 1; TestRenderFrame* subframe = static_cast(RenderFrameImpl::FromWebFrame( frame()->GetWebFrame()->FindFrameByName("frame"))); FrameLoadWaiter waiter(subframe); subframe->Navigate(std::move(common_params), std::move(commit_params)); waiter.Wait(); // Copy the document content to std::string and compare with the // expected result. const int kMaxOutputCharacters = 256; std::string output = TestWebFrameContentDumper::DumpWebViewAsText( web_view_, kMaxOutputCharacters) .Utf8(); EXPECT_EQ(output, "hello \n\nworld"); } // This test ensures that a RenderFrame object is created for the top level // frame in the RenderView. TEST_F(RenderViewImplTest, BasicRenderFrame) { EXPECT_TRUE(GetMainRenderFrame()); } namespace { class MessageOrderFakeRenderWidgetHost : public FakeRenderWidgetHost { public: MOCK_METHOD1(TextInputStateChanged, void(ui::mojom::TextInputStatePtr state)); }; class TextSelectionChangedLocalFrameHost : public LocalFrameHostInterceptor { public: explicit TextSelectionChangedLocalFrameHost( blink::AssociatedInterfaceProvider* provider) : LocalFrameHostInterceptor(provider) {} MOCK_METHOD3(TextSelectionChanged, void(const std::u16string& text, uint32_t offset, const gfx::Range& range)); }; } // namespace class RenderViewImplTextInputMessageOrder : public RenderViewImplTest { public: using MockedTestRenderFrame = MockedLocalFrameHostInterceptorTestRenderFrame< TextSelectionChangedLocalFrameHost>; RenderViewImplTextInputMessageOrder() : RenderViewImplTest(&MockedTestRenderFrame::CreateTestRenderFrame) {} std::unique_ptr CreateRenderWidgetHost() override { return std::make_unique(); } MessageOrderFakeRenderWidgetHost* GetMessageOrderFakeRenderWidgetHost() { return static_cast( render_widget_host_.get()); } TextSelectionChangedLocalFrameHost* GetMockLocalFrameHost() { return static_cast(frame()) ->mock_local_frame_host(); } }; // Failing on Windows; see https://crbug.com/1134571. #if BUILDFLAG(IS_WIN) #define MAYBE_MessageOrderInDidChangeSelection \ DISABLED_MessageOrderInDidChangeSelection #else #define MAYBE_MessageOrderInDidChangeSelection MessageOrderInDidChangeSelection #endif TEST_F(RenderViewImplTextInputMessageOrder, MAYBE_MessageOrderInDidChangeSelection) { LoadHTML(""); // TextInputStateChanged should be called earlier than TextSelectionChanged. testing::InSequence sequence; // TextInputStateChanged and TextSelectionChanged should be called once each. EXPECT_CALL(*GetMessageOrderFakeRenderWidgetHost(), TextInputStateChanged(testing::_)) .Times(1); EXPECT_CALL(*GetMockLocalFrameHost(), TextSelectionChanged(testing::_, testing::_, testing::_)) .Times(1); main_frame_widget()->SetHandlingInputEvent(true); ExecuteJavaScriptForTests("document.getElementById('test').focus();"); } class RendererErrorPageTest : public RenderViewImplTest { public: ContentRendererClient* CreateContentRendererClient() override { return new TestContentRendererClient; } RenderFrameImpl* frame() { return static_cast(GetMainRenderFrame()); } private: class TestContentRendererClient : public ContentRendererClient { public: void PrepareErrorPage(content::RenderFrame* render_frame, const blink::WebURLError& error, const std::string& http_method, content::mojom::AlternativeErrorPageOverrideInfoPtr alternative_error_page_info, std::string* error_html) override { if (error_html) *error_html = "A suffusion of yellow."; } }; }; TEST_F(RendererErrorPageTest, RegularError) { auto common_params = blink::CreateCommonNavigationParams(); common_params->navigation_type = blink::mojom::NavigationType::DIFFERENT_DOCUMENT; common_params->url = GURL("http://example.com/error-page"); auto commit_params = DummyCommitNavigationParams(); commit_params->origin_to_commit = url::Origin::Create(common_params->url).DeriveNewOpaqueOrigin(); TestRenderFrame* main_frame = static_cast(frame()); main_frame->NavigateWithError( std::move(common_params), std::move(commit_params), net::ERR_FILE_NOT_FOUND, net::ResolveErrorInfo(net::OK), "A suffusion of yellow."); // The error page itself is loaded asynchronously. FrameLoadWaiter(main_frame).Wait(); const int kMaxOutputCharacters = 22; EXPECT_EQ("A suffusion of yellow.", TestWebFrameContentDumper::DumpWebViewAsText(web_view_, kMaxOutputCharacters) .Ascii()); } TEST_F(RenderViewImplTest, SetAccessibilityMode) { ASSERT_TRUE(GetAccessibilityMode().is_mode_off()); ASSERT_TRUE(GetRenderAccessibilityManager()); ASSERT_FALSE(GetRenderAccessibilityManager()->GetRenderAccessibilityImpl()); GetRenderAccessibilityManager()->SetMode(ui::kAXModeWebContentsOnly, 1); ASSERT_TRUE(GetAccessibilityMode() == ui::kAXModeWebContentsOnly); ASSERT_TRUE(GetRenderAccessibilityManager()->GetRenderAccessibilityImpl()); GetRenderAccessibilityManager()->SetMode(ui::AXMode::kNone, 0); ASSERT_TRUE(GetAccessibilityMode().is_mode_off()); ASSERT_FALSE(GetRenderAccessibilityManager()->GetRenderAccessibilityImpl()); GetRenderAccessibilityManager()->SetMode(ui::kAXModeComplete, 1); ASSERT_TRUE(GetAccessibilityMode() == ui::kAXModeComplete); ASSERT_TRUE(GetRenderAccessibilityManager()->GetRenderAccessibilityImpl()); } TEST_F(RenderViewImplTest, AccessibilityModeOnClosingConnection) { // Force the RenderAccessibilityManager to bind a pending receiver so that we // can test what happens after closing the remote endpoint. mojo::AssociatedRemote remote; GetRenderAccessibilityManager()->BindReceiver( remote.BindNewEndpointAndPassReceiver()); GetRenderAccessibilityManager()->SetMode(ui::kAXModeWebContentsOnly, 1); ASSERT_TRUE(GetAccessibilityMode() == ui::kAXModeWebContentsOnly); ASSERT_TRUE(GetRenderAccessibilityManager()->GetRenderAccessibilityImpl()); // Closing the remote endpoint of the mojo pipe gets accessibility disabled // for the frame and the RenderAccessibility object deleted. remote.reset(); base::RunLoop().RunUntilIdle(); ASSERT_TRUE(GetRenderAccessibilityManager()); ASSERT_TRUE(GetAccessibilityMode().is_mode_off()); ASSERT_FALSE(GetRenderAccessibilityManager()->GetRenderAccessibilityImpl()); } // Checks that when a navigation starts in the renderer, |navigation_start| is // recorded at an appropriate time and is passed in the corresponding message. TEST_F(RenderViewImplTest, RendererNavigationStartTransmittedToBrowser) { base::TimeTicks lower_bound_navigation_start(base::TimeTicks::Now()); CommonParamsFrameLoadWaiter waiter(frame()); frame()->LoadHTMLStringForTesting("hello world", GURL("data:text/html,"), "UTF-8", GURL(), false /* replace_current_item */); waiter.Wait(); EXPECT_FALSE(waiter.common_params()->navigation_start.is_null()); EXPECT_LE(lower_bound_navigation_start, waiter.common_params()->navigation_start); } // Checks that a browser-initiated navigation in an initial document that was // not accessed uses browser-side timestamp. // This test assumes that |frame()| contains an unaccessed initial document at // start. TEST_F(RenderViewImplTest, BrowserNavigationStart) { auto common_params = MakeCommonNavigationParams(-base::Seconds(1)); CommonParamsFrameLoadWaiter waiter(frame()); frame()->Navigate(common_params.Clone(), DummyCommitNavigationParams()); waiter.Wait(); EXPECT_EQ(common_params->navigation_start, waiter.common_params()->navigation_start); } // Sanity check for the Navigation Timing API |navigationStart| override. We // are asserting only most basic constraints, as TimeTicks (passed as the // override) are not comparable with the wall time (returned by the Blink API). TEST_F(RenderViewImplTest, BrowserNavigationStartSanitized) { // Verify that a navigation that claims to have started in the future - 42 // days from now is *not* reported as one that starts in the future; as we // sanitize the override allowing a maximum of ::Now(). auto late_common_params = MakeCommonNavigationParams(base::Days(42)); late_common_params->method = "POST"; frame()->Navigate(late_common_params.Clone(), DummyCommitNavigationParams()); base::RunLoop().RunUntilIdle(); base::Time after_navigation = base::Time::Now() + base::Days(1); base::Time late_nav_reported_start = base::Time::FromDoubleT( GetMainFrame()->PerformanceMetricsForReporting().NavigationStart()); EXPECT_LE(late_nav_reported_start, after_navigation); } // Checks that a browser-initiated navigation in an initial document that has // been accessed uses browser-side timestamp (there may be arbitrary // content and/or scripts injected, including beforeunload handler that shows // a confirmation dialog). TEST_F(RenderViewImplTest, NavigationStartWhenInitialDocumentWasAccessed) { // Trigger a didAccessInitialDocument notification. ExecuteJavaScriptForTests("document.title = 'Hi!';"); auto common_params = MakeCommonNavigationParams(-base::Seconds(1)); CommonParamsFrameLoadWaiter waiter(frame()); frame()->Navigate(common_params.Clone(), DummyCommitNavigationParams()); waiter.Wait(); EXPECT_EQ(common_params->navigation_start, waiter.common_params()->navigation_start); } TEST_F(RenderViewImplTest, NavigationStartForReload) { const char url_string[] = "data:text/html,

Page

"; // Navigate once, then reload. LoadHTML(url_string); base::RunLoop().RunUntilIdle(); render_thread_->sink().ClearMessages(); auto common_params = blink::CreateCommonNavigationParams(); common_params->url = GURL(url_string); common_params->navigation_type = blink::mojom::NavigationType::RELOAD; common_params->transition = ui::PAGE_TRANSITION_RELOAD; // The browser navigation_start should not be used because beforeunload will // be fired during Navigate. CommonParamsFrameLoadWaiter waiter(frame()); frame()->Navigate(common_params.Clone(), DummyCommitNavigationParams()); waiter.Wait(); // The browser navigation_start is always used. EXPECT_EQ(common_params->navigation_start, waiter.common_params()->navigation_start); } TEST_F(RenderViewImplTest, NavigationStartForSameProcessHistoryNavigation) { LoadHTML("

Page A

"); LoadHTML("

Page B

"); blink::PageState back_state = GetCurrentPageState(); LoadHTML("

Page C

"); blink::PageState forward_state = GetCurrentPageState(); base::RunLoop().RunUntilIdle(); render_thread_->sink().ClearMessages(); // Go back. auto common_params_back = blink::CreateCommonNavigationParams(); common_params_back->url = GURL("data:text/html;charset=utf-8,

Page B

"); common_params_back->transition = ui::PAGE_TRANSITION_FORWARD_BACK; common_params_back->navigation_type = blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT; auto final_common_params = GoToOffsetWithParams(-1, back_state, common_params_back.Clone(), DummyCommitNavigationParams()); // The browser navigation_start is always used. EXPECT_EQ(common_params_back->navigation_start, final_common_params->navigation_start); // Go forward. auto common_params_forward = blink::CreateCommonNavigationParams(); common_params_forward->url = GURL("data:text/html;charset=utf-8,

Page C

"); common_params_forward->transition = ui::PAGE_TRANSITION_FORWARD_BACK; common_params_forward->navigation_type = blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT; auto final_common_params2 = GoToOffsetWithParams(-1, back_state, common_params_back.Clone(), DummyCommitNavigationParams()); EXPECT_EQ(common_params_forward->navigation_start, final_common_params2->navigation_start); } TEST_F(RenderViewImplTest, NavigationStartForCrossProcessHistoryNavigation) { auto common_params = MakeCommonNavigationParams(-base::Seconds(1)); common_params->transition = ui::PAGE_TRANSITION_FORWARD_BACK; common_params->navigation_type = blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT; auto commit_params = DummyCommitNavigationParams(); commit_params->page_state = blink::PageState::CreateForTesting( common_params->url, false, nullptr, nullptr) .ToEncodedData(); commit_params->nav_entry_id = 42; commit_params->pending_history_list_offset = 1; commit_params->current_history_list_offset = 0; commit_params->current_history_list_length = 1; CommonParamsFrameLoadWaiter waiter(frame()); frame()->Navigate(common_params.Clone(), std::move(commit_params)); waiter.Wait(); EXPECT_EQ(common_params->navigation_start, waiter.common_params()->navigation_start); } TEST_F(RenderViewImplTest, PreferredSizeZoomed) { LoadHTML( "" "

"); // For unknown reasons, setting fixed scrollbar width using // ::-webkit-scrollbar makes Mac bots flaky (crbug.com/785088). // Measure native scrollbar width instead. int scrollbar_width = GetScrollbarWidth(); EnablePreferredSizeMode(); gfx::Size size = GetPreferredSize(); EXPECT_EQ(gfx::Size(400 + scrollbar_width, 400), size); // The size is in DIP. Changing the scale factor should not change // the preferred size. (Caveat: a page may apply different layout for // high DPI, in which case, the size may differ.) SetDeviceScaleFactor(2.f); size = GetPreferredSize(); EXPECT_EQ(gfx::Size(400 + scrollbar_width, 400), size); } // Ensure the `blink::WebView` history list is properly updated when starting a // new browser-initiated navigation. TEST_F(RenderViewImplTest, HistoryIsProperlyUpdatedOnNavigation) { blink::WebView* webview = web_view_; EXPECT_EQ(0, webview->HistoryBackListCount()); EXPECT_EQ(0, webview->HistoryBackListCount() + webview->HistoryForwardListCount() + 1); // Receive a CommitNavigation message with history parameters. auto commit_params = DummyCommitNavigationParams(); commit_params->current_history_list_offset = 1; commit_params->current_history_list_length = 2; auto common_params = blink::CreateCommonNavigationParams(); common_params->navigation_type = blink::mojom::NavigationType::DIFFERENT_DOCUMENT; common_params->should_replace_current_entry = true; frame()->Navigate(std::move(common_params), std::move(commit_params)); // The current history list in `blink::WebView` is updated. EXPECT_EQ(1, webview->HistoryBackListCount()); EXPECT_EQ(2, webview->HistoryBackListCount() + webview->HistoryForwardListCount() + 1); } // Ensure the `blink::WebView` history list is properly updated when starting a // new history browser-initiated navigation. TEST_F(RenderViewImplTest, HistoryIsProperlyUpdatedOnHistoryNavigation) { blink::WebView* webview = web_view_; EXPECT_EQ(0, webview->HistoryBackListCount()); EXPECT_EQ(0, webview->HistoryBackListCount() + webview->HistoryForwardListCount() + 1); // Receive a CommitNavigation message with history parameters. auto commit_params = DummyCommitNavigationParams(); commit_params->current_history_list_offset = 1; commit_params->current_history_list_length = 25; commit_params->pending_history_list_offset = 12; commit_params->nav_entry_id = 777; auto common_params = blink::CreateCommonNavigationParams(); common_params->navigation_type = blink::mojom::NavigationType::DIFFERENT_DOCUMENT; common_params->should_replace_current_entry = true; frame()->Navigate(std::move(common_params), std::move(commit_params)); // The current history list in `blink::WebView` is updated. EXPECT_EQ(12, webview->HistoryBackListCount()); EXPECT_EQ(25, webview->HistoryBackListCount() + webview->HistoryForwardListCount() + 1); } // Ensure the `blink::WebView` history list is properly updated when starting a // new history browser-initiated navigation with should_clear_history_list TEST_F(RenderViewImplTest, HistoryIsProperlyUpdatedOnShouldClearHistoryList) { blink::WebView* webview = web_view_; EXPECT_EQ(0, webview->HistoryBackListCount()); EXPECT_EQ(0, webview->HistoryBackListCount() + webview->HistoryForwardListCount() + 1); // Receive a CommitNavigation message with history parameters. auto commit_params = DummyCommitNavigationParams(); commit_params->current_history_list_offset = 12; commit_params->current_history_list_length = 25; commit_params->should_clear_history_list = true; frame()->Navigate(blink::CreateCommonNavigationParams(), std::move(commit_params)); // The current history list in `blink::WebView` is updated. EXPECT_EQ(0, webview->HistoryBackListCount()); EXPECT_EQ(1, webview->HistoryBackListCount() + webview->HistoryForwardListCount() + 1); } namespace { class AddMessageToConsoleMockLocalFrameHost : public LocalFrameHostInterceptor { public: explicit AddMessageToConsoleMockLocalFrameHost( blink::AssociatedInterfaceProvider* provider) : LocalFrameHostInterceptor(provider) {} void DidAddMessageToConsole( blink::mojom::ConsoleMessageLevel log_level, const std::u16string& msg, uint32_t line_number, const absl::optional& source_id, const absl::optional& untrusted_stack_trace) override { if (did_add_message_to_console_callback_) { std::move(did_add_message_to_console_callback_).Run(msg); } } void SetDidAddMessageToConsoleCallback( base::OnceCallback callback) { did_add_message_to_console_callback_ = std::move(callback); } private: base::OnceCallback did_add_message_to_console_callback_; }; } // namespace class RenderViewImplAddMessageToConsoleTest : public RenderViewImplTest { public: using MockedTestRenderFrame = MockedLocalFrameHostInterceptorTestRenderFrame< AddMessageToConsoleMockLocalFrameHost>; RenderViewImplAddMessageToConsoleTest() : RenderViewImplTest(&MockedTestRenderFrame::CreateTestRenderFrame) {} AddMessageToConsoleMockLocalFrameHost* message_mock_frame_host() { return static_cast(frame()) ->mock_local_frame_host(); } }; // Tests that there's no UaF after dispatchBeforeUnloadEvent. // See https://crbug.com/666714. TEST_F(RenderViewImplAddMessageToConsoleTest, DispatchBeforeUnloadCanDetachFrame) { LoadHTML( ""); // Create a callback that unloads the frame when the 'OnBeforeUnload called' // log is printed from the beforeunload handler. base::RunLoop run_loop; bool was_callback_run = false; message_mock_frame_host()->SetDidAddMessageToConsoleCallback( base::BindLambdaForTesting([&](const std::u16string& msg) { // Makes sure this happens during the beforeunload handler. EXPECT_EQ(u"OnBeforeUnload called", msg); // Unloads the main frame. static_cast(frame())->Unload( /*is_loading=*/false, blink::mojom::FrameReplicationState::New(), blink::RemoteFrameToken(), CreateStubRemoteFrameInterfaces(), CreateStubRemoteMainFrameInterfaces()); was_callback_run = true; run_loop.Quit(); })); // Simulate a BeforeUnload IPC received from the browser. frame()->SimulateBeforeUnload(false); run_loop.Run(); ASSERT_TRUE(was_callback_run); } namespace { class AlertDialogMockLocalFrameHost : public LocalFrameHostInterceptor { public: explicit AlertDialogMockLocalFrameHost( blink::AssociatedInterfaceProvider* provider) : LocalFrameHostInterceptor(provider) {} MOCK_METHOD3(RunModalAlertDialog, void(const std::u16string& alert_message, bool disable_third_party_subframe_suppresion, RunModalAlertDialogCallback callback)); }; } // namespace class RenderViewImplModalDialogTest : public RenderViewImplTest { public: using MockedTestRenderFrame = MockedLocalFrameHostInterceptorTestRenderFrame< AlertDialogMockLocalFrameHost>; RenderViewImplModalDialogTest() : RenderViewImplTest(&MockedTestRenderFrame::CreateTestRenderFrame) {} AlertDialogMockLocalFrameHost* alert_mock_frame_host() { return static_cast(frame()) ->mock_local_frame_host(); } }; // Test that invoking one of the modal dialogs doesn't crash. TEST_F(RenderViewImplModalDialogTest, ModalDialogs) { LoadHTML(""); std::u16string alert_message = u"Please don't crash"; EXPECT_CALL(*alert_mock_frame_host(), RunModalAlertDialog(alert_message, false, testing::_)) .WillOnce(base::test::RunOnceCallback<2>()); frame()->GetWebFrame()->Alert(WebString::FromUTF16(alert_message)); } TEST_F(RenderViewImplBlinkSettingsTest, Default) { DoSetUp(); EXPECT_FALSE(settings()->ViewportEnabled()); } TEST_F(RenderViewImplBlinkSettingsTest, CommandLine) { base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( blink::switches::kBlinkSettings, "viewportEnabled=true"); DoSetUp(); EXPECT_TRUE(settings()->ViewportEnabled()); } // Ensure that setting default page scale limits immediately recomputes the // minimum scale factor to the final value. With // shrinks_viewport_contents_to_fit, Blink clamps the minimum cased on the // content width. In this case, that'll always be 1. TEST_F(RenderViewImplBlinkSettingsTest, DefaultPageScaleSettings) { DoSetUp(); LoadHTML( ""); EXPECT_EQ(1.f, web_view_->PageScaleFactor()); EXPECT_EQ(1.f, web_view_->MinimumPageScaleFactor()); blink::web_pref::WebPreferences prefs; prefs.shrinks_viewport_contents_to_fit = true; prefs.default_minimum_page_scale_factor = 0.1f; prefs.default_maximum_page_scale_factor = 5.5f; web_view_->SetWebPreferences(prefs); EXPECT_EQ(1.f, web_view_->PageScaleFactor()); EXPECT_EQ(1.f, web_view_->MinimumPageScaleFactor()); EXPECT_EQ(5.5f, web_view_->MaximumPageScaleFactor()); } TEST_F(RenderViewImplScaleFactorTest, ScreenMetricsEmulationWithOriginalDSF1) { SetDeviceScaleFactor(1.f); LoadHTML(""); { SCOPED_TRACE("327x415 1dpr"); TestEmulatedSizeDprDsf(327, 415, 1.f, 1.f); } { SCOPED_TRACE("327x415 1.5dpr"); TestEmulatedSizeDprDsf(327, 415, 1.5f, 1.f); } { SCOPED_TRACE("1005x1102 2dpr"); TestEmulatedSizeDprDsf(1005, 1102, 2.f, 1.f); } { SCOPED_TRACE("1005x1102 3dpr"); TestEmulatedSizeDprDsf(1005, 1102, 3.f, 1.f); } ReceiveDisableDeviceEmulation(); blink::DeviceEmulationParams params; ReceiveEnableDeviceEmulation(params); // Don't disable here to test that emulation is being shutdown properly. } TEST_F(RenderViewImplScaleFactorTest, ScreenMetricsEmulationWithOriginalDSF2) { float device_scale = 2.f; SetDeviceScaleFactor(device_scale); LoadHTML(""); { SCOPED_TRACE("327x415 1dpr"); TestEmulatedSizeDprDsf(327, 415, 1.f, device_scale); } { SCOPED_TRACE("327x415 1.5dpr"); TestEmulatedSizeDprDsf(327, 415, 1.5f, device_scale); } { SCOPED_TRACE("1005x1102 2dpr"); TestEmulatedSizeDprDsf(1005, 1102, 2.f, device_scale); } { SCOPED_TRACE("1005x1102 3dpr"); TestEmulatedSizeDprDsf(1005, 1102, 3.f, device_scale); } ReceiveDisableDeviceEmulation(); blink::DeviceEmulationParams params; ReceiveEnableDeviceEmulation(params); // Don't disable here to test that emulation is being shutdown properly. } TEST_F(RenderViewImplScaleFactorTest, ConvertViewportToWindow) { SetDeviceScaleFactor(1.f); { gfx::Rect rect(20, 10, 200, 100); gfx::Rect rect_in_dips = main_frame_widget()->BlinkSpaceToEnclosedDIPs(rect); EXPECT_EQ(rect, rect_in_dips); } SetDeviceScaleFactor(2.f); { gfx::Rect rect_in_dips = main_frame_widget()->BlinkSpaceToEnclosedDIPs( gfx::Rect(20, 10, 200, 100)); EXPECT_EQ(10, rect_in_dips.x()); EXPECT_EQ(5, rect_in_dips.y()); EXPECT_EQ(100, rect_in_dips.width()); EXPECT_EQ(50, rect_in_dips.height()); } } #if BUILDFLAG(IS_MAC) || defined(USE_AURA) TEST_F(RenderViewImplScaleFactorTest, DISABLED_GetCompositionCharacterBoundsTest) { // http://crbug.com/582016 SetDeviceScaleFactor(1.f); LoadHTML(""); ExecuteJavaScriptForTests("document.getElementById('test').focus();"); auto* widget_input_handler = GetWidgetInputHandler(); const std::u16string empty_string; const std::vector empty_ime_text_span; std::vector bounds_at_1x; widget_input_handler->SetFocus(blink::mojom::FocusState::kFocused); // ASCII composition const std::u16string ascii_composition = u"aiueo"; widget_input_handler->ImeSetComposition( ascii_composition, empty_ime_text_span, gfx::Range::InvalidRange(), 0, 0, base::DoNothing()); bounds_at_1x = LastCompositionBounds(); ASSERT_EQ(ascii_composition.size(), bounds_at_1x.size()); SetDeviceScaleFactor(2.f); std::vector bounds_at_2x = LastCompositionBounds(); ASSERT_EQ(bounds_at_1x.size(), bounds_at_2x.size()); for (size_t i = 0; i < bounds_at_1x.size(); i++) { const gfx::Rect& b1 = bounds_at_1x[i]; const gfx::Rect& b2 = bounds_at_2x[i]; gfx::Vector2d origin_diff = b1.origin() - b2.origin(); // The bounds may not be exactly same because the font metrics are different // at 1x and 2x. Just make sure that the difference is small. EXPECT_LT(origin_diff.x(), 2); EXPECT_LT(origin_diff.y(), 2); EXPECT_LT(std::abs(b1.width() - b2.width()), 3); EXPECT_LT(std::abs(b1.height() - b2.height()), 2); } } #endif #if !BUILDFLAG(IS_ANDROID) // No extensions/autoresize on Android. namespace { // Don't use text as it text will change the size in DIP at different // scale factor. const char kAutoResizeTestPage[] = "

"; } // namespace TEST_F(RenderViewImplScaleFactorTest, AutoResize) { EnableAutoResize(gfx::Size(5, 5), gfx::Size(1000, 1000)); LoadHTML(kAutoResizeTestPage); gfx::Size size_at_1x = MainWidgetSizeInDIPS(); ASSERT_FALSE(size_at_1x.IsEmpty()); SetDeviceScaleFactor(2.f); LoadHTML(kAutoResizeTestPage); gfx::Size size_at_2x = MainWidgetSizeInDIPS(); EXPECT_EQ(size_at_1x, size_at_2x); } TEST_F(RenderViewImplTest, ZoomLevelUpdate) { // 0 will use the minimum zoom level, which is the default, nothing will // change. EXPECT_FLOAT_EQ(0u, web_view_->ZoomLevel()); double zoom_level = blink::PageZoomFactorToZoomLevel(0.25); // Change the zoom level to 25% and check if the view gets the change. main_frame_widget()->SetZoomLevelForTesting(zoom_level); // Use EXPECT_FLOAT_EQ here because view()->GetZoomLevel returns a float. EXPECT_FLOAT_EQ(zoom_level, web_view_->ZoomLevel()); } #endif TEST_F(RenderViewImplTest, OriginTrialDisabled) { // HTML Document with no origin trial. const char kHTMLWithNoOriginTrial[] = "" "" "" "Origin Trial Test" "" ""; // Override the origin trial policy to use the test keys. blink::ScopedTestOriginTrialPolicy policy; // Set the document URL. LoadHTMLWithUrlOverride(kHTMLWithNoOriginTrial, "https://example.test/"); blink::WebFrame* web_frame = frame()->GetWebFrame(); ASSERT_TRUE(web_frame); ASSERT_TRUE(web_frame->IsWebLocalFrame()); blink::WebDocument web_doc = web_frame->ToWebLocalFrame()->GetDocument(); EXPECT_FALSE(blink::WebOriginTrials::isTrialEnabled(&web_doc, "Frobulate")); // Reset the origin trial policy. blink::TrialTokenValidator::ResetOriginTrialPolicyGetter(); } TEST_F(RenderViewImplTest, OriginTrialEnabled) { // HTML Document with an origin trial. // Note: The token below will expire in 2033. It was generated with the // command: // generate_token.py https://example.test Frobulate \ // -expire-timestamp=2000000000 const char kHTMLWithOriginTrial[] = "" "" "" "Origin Trial Test" "" "" ""; // Override the origin trial policy to use the test keys. blink::ScopedTestOriginTrialPolicy policy; // Set the document URL so the origin is correct for the trial. LoadHTMLWithUrlOverride(kHTMLWithOriginTrial, "https://example.test/"); blink::WebFrame* web_frame = frame()->GetWebFrame(); ASSERT_TRUE(web_frame); ASSERT_TRUE(web_frame->IsWebLocalFrame()); blink::WebDocument web_doc = web_frame->ToWebLocalFrame()->GetDocument(); EXPECT_TRUE(blink::WebOriginTrials::isTrialEnabled(&web_doc, "Frobulate")); // Reset the origin trial policy. blink::TrialTokenValidator::ResetOriginTrialPolicyGetter(); } } // namespace content