to be returned as a focus // node for selection, most frequently when a triple click causes an entire // range of text to be selected, including non-text nodes. This can cause // inconsistencies in how the selection is handled. e.g. the focus node can // be before the anchor node and set to a non-text node, which can cause // page_handler_->OnSelectionChange to be incorrectly triggered, resulting // in a failing DCHECK. Therefore, return early if this happens. This check // does not apply to pdfs. if (!model_.is_pdf() && (!focus_node->IsText() || !anchor_node->IsText())) { return; } // If the selection change matches the tree's selection, this means it was // set by the controller. Javascript selections set by the controller are // always forward selections. This means the anchor node always comes before // the focus node. if (anchor_node_id == model_.start_node_id() && anchor_offset == model_.start_offset() && focus_node_id == model_.end_node_id() && focus_offset == model_.end_offset()) { return; } model_.increment_selections_from_reading_mode(); page_handler_->OnSelectionChange(model_.active_tree_id(), anchor_node_id, anchor_offset, focus_node_id, focus_offset); } void ReadAnythingAppController::OnCollapseSelection() { model_.increment_selections_from_reading_mode(); if (model_.is_pdf()) { // CollapseSelection does nothing in pdfs, so just set an empty selection // instead. page_handler_->OnSelectionChange( model_.active_tree_id(), model_.start_node_id(), model_.start_offset(), model_.start_node_id(), model_.start_offset()); } else { page_handler_->OnCollapseSelection(); } } void ReadAnythingAppController::ResetGranularityIndex() { read_aloud_model_.ResetGranularityIndex(); } void ReadAnythingAppController::InitAXPositionWithNode( const ui::AXNodeID& starting_node_id) { ui::AXNode* ax_node = model_.GetAXNode(starting_node_id); read_aloud_model_.InitAXPositionWithNode(ax_node, model_.active_tree_id()); // TODO: crbug.com/411198154: This should only be called if the ax position // is not already initialized. PreprocessTextForSpeech(); } bool ReadAnythingAppController::IsSpeechTreeInitialized() { return read_aloud_model_.speech_tree_initialized(); } std::u16string ReadAnythingAppController::GetCurrentTextContent() { return read_aloud_model_ .GetCurrentText(model_.is_pdf(), model_.IsDocs(), model_.GetCurrentlyVisibleNodes()) .text; } void ReadAnythingAppController::PreprocessTextForSpeech() { read_aloud_model_.PreprocessTextForSpeech(model_.is_pdf(), model_.IsDocs(), model_.GetCurrentlyVisibleNodes()); } void ReadAnythingAppController::MovePositionToNextGranularity() { read_aloud_model_.MovePositionToNextGranularity(); } void ReadAnythingAppController::MovePositionToPreviousGranularity() { read_aloud_model_.MovePositionToPreviousGranularity(); } void ReadAnythingAppController::SetLanguageForTesting( const std::string& language_code) { SetLanguageCode(language_code); } void ReadAnythingAppController::SetLanguageCode(const std::string& code) { if (code.empty()) { model_.set_requires_tree_lang(true); return; } std::string base_lang = std::string(language::ExtractBaseLanguage(code)); model_.SetBaseLanguageCode(base_lang); ExecuteJavaScript("chrome.readingMode.languageChanged();"); } #if BUILDFLAG(IS_CHROMEOS) void ReadAnythingAppController::OnDeviceLocked() { if (read_aloud_model_.speech_playing()) { read_aloud_model_.LogSpeechStop( ReadAloudAppModel::ReadAloudStopSource::kLockChromeosDevice); } RecordSessionMetricsIfShownOrRecentlyHidden(); // Signal to the WebUI that the device has been locked. We'll only receive // this callback on ChromeOS. ExecuteJavaScript("chrome.readingMode.onLockScreen();"); } #else void ReadAnythingAppController::OnTtsEngineInstalled() { VLOG(1) << "OnTtsEngineInstalled"; ExecuteJavaScript("chrome.readingMode.onTtsEngineInstalled()"); } #endif void ReadAnythingAppController::OnReadingModeHidden(bool tab_active) { page_handler_->AckReadingModeHidden(); model_.set_will_hide(true); // If the tab is not active but RM is hidden, then the tab was switched and // speech was not stopped. If the tab is still active and RM is hidden, then // RM was closed, so log the speech stopped. if (tab_active) { ReadingModeWillClose(); if (read_aloud_model_.speech_playing()) { read_aloud_model_.LogSpeechStop( ReadAloudAppModel::ReadAloudStopSource::kCloseReadingMode); } } // Since it's known that reading mode was just hidden, ensure that metrics // are still logged. RecordSessionMetricsIfShownOrRecentlyHidden(/*just_hidden=*/true); } void ReadAnythingAppController::OnReadingModeShown( read_anything::mojom::ReadAnythingOpenTrigger open_trigger) { // TODO (crbug.com/494307454): Add test to verify that duplicate calls of // OnReadingModeShown() won't affect Read Aloud's audio playback state (other // than the playOnOpen state). if (open_trigger == read_anything::mojom::ReadAnythingOpenTrigger:: kListenToThisPageContextMenu) { ExecuteJavaScript("chrome.readingMode.setPlayOnOpen(true);"); } if (ax_tree_ready_for_current_active_tree_measured_) { MaybeLogAXTreeReady(); } } void ReadAnythingAppController::OnSpeechEngineFirstStall() { DUMP_WILL_BE_CHECK(false) << "Speech engine stalled after 10 seconds"; } void ReadAnythingAppController::OnSpeechEngineStalled() { DUMP_WILL_BE_CHECK(false) << "Speech engine stalled after recovery timeout"; page_handler_->OnSpeechEngineStalled(); } void ReadAnythingAppController::OnTabWillDetach() { model_.set_will_hide(true); if (read_aloud_model_.speech_playing()) { read_aloud_model_.LogSpeechStop( ReadAloudAppModel::ReadAloudStopSource::kCloseTabOrWindow); ReadingModeWillClose(); } RecordSessionMetricsIfShownOrRecentlyHidden(); } void ReadAnythingAppController::ReadingModeWillClose() { if (!features::IsImmersiveReadAnythingEnabled()) { return; } ExecuteJavaScript("chrome.readingMode.readingModeWillClose();"); } void ReadAnythingAppController::CloseUI() { // This CloseUI() method is only used for the immersive UI, so skip if flag is // not enabled if (!features::IsImmersiveReadAnythingEnabled()) { return; } page_handler_->CloseUI(); } void ReadAnythingAppController::TogglePresentation() { if (!features::IsImmersiveReadAnythingEnabled()) { return; } page_handler_->TogglePresentation(); } void ReadAnythingAppController::OnTabMuteStateChange(bool muted) { ExecuteJavaScript("chrome.readingMode.onTabMuteStateChange(" + base::ToString(muted) + ")"); } void ReadAnythingAppController::SetDefaultLanguageCode( const std::string& code) { std::string default_lang = std::string(language::ExtractBaseLanguage(code)); // If the default language code is empty, continue to use the default // language code, as defined by ReadAnythingAppModel, currently 'en' if (default_lang.length() > 0) { read_aloud_model_.set_default_language_code(default_lang); } } void ReadAnythingAppController::ShouldShowUI() { page_handler_factory_->ShouldShowUI(); } void ReadAnythingAppController::OnIsSpeechActiveChanged(bool is_speech_active) { // Don't send event updates if the speech playing state hasn't actually // changed. This can get triggered incorrectly when changing pages. if (read_aloud_model_.speech_playing() == is_speech_active) { return; } if (is_speech_active && IsImmersiveEnabled()) { read_aloud_model_.LogPlaybackContext( model_.active_presentation_state() == read_anything::mojom::ReadAnythingPresentationState:: kInImmersiveOverlay ? ReadAloudAppModel::ReadAnythingPlaybackContext::kImmersive : ReadAloudAppModel::ReadAnythingPlaybackContext::kSidePanel); } read_aloud_model_.SetSpeechPlaying(is_speech_active); // If speech was just stopped, we can now process any updates that were // queued while speech was playing if there are no other factors blocking // processing ProcessPendingUpdatesIfAllowed(); } void ReadAnythingAppController::OnIsAudioCurrentlyPlayingChanged( bool is_audio_currently_playing) { if (read_aloud_model_.audio_currently_playing() == is_audio_currently_playing) { return; } read_aloud_model_.SetAudioCurrentlyPlaying(is_audio_currently_playing); page_handler_->OnReadAloudAudioStateChange(is_audio_currently_playing); } int ReadAnythingAppController::GetAccessibleBoundary(const std::u16string& text, int max_text_length) { std::vector offsets; const std::u16string shorter_string = text.substr(0, max_text_length); size_t sentence_ends_short = ui::FindAccessibleTextBoundary( shorter_string, offsets, ax::mojom::TextBoundary::kSentenceStart, 0, ax::mojom::MoveDirection::kForward, ax::mojom::TextAffinity::kDefaultValue); size_t sentence_ends_long = ui::FindAccessibleTextBoundary( text, offsets, ax::mojom::TextBoundary::kSentenceStart, 0, ax::mojom::MoveDirection::kForward, ax::mojom::TextAffinity::kDefaultValue); // Compare the index result for the sentence of maximum text length and of // the longer text string. If the two values are the same, the index is // correct. If they are different, the maximum text length may have // incorrectly spliced a word (e.g. returned "this is a sen" instead of // "this is a" or "this is a sentence"), so if this is the case, we'll want // to use the last word boundary instead. if (sentence_ends_short == sentence_ends_long) { return sentence_ends_short; } size_t word_ends = ui::FindAccessibleTextBoundary( shorter_string, offsets, ax::mojom::TextBoundary::kWordStart, shorter_string.length() - 1, ax::mojom::MoveDirection::kBackward, ax::mojom::TextAffinity::kDefaultValue); return word_ends; } v8::Local ReadAnythingAppController::GetCurrentTextSegments() { v8::Isolate* isolate = render_frame()->GetWebFrame()->GetAgentGroupScheduler()->Isolate(); auto context = isolate->GetCurrentContext(); std::vector nodes = read_aloud_model_.GetCurrentTextSegments( model_.is_pdf(), model_.IsDocs(), model_.GetCurrentlyVisibleNodes()); v8::Local highlight_array = v8::Array::New(isolate, nodes.size()); for (int i = 0; i < (int)nodes.size(); i++) { v8::Local obj = v8::Object::New(isolate); auto checked = obj->DefineOwnProperty( context, v8::String::NewFromUtf8(isolate, "nodeId").ToLocalChecked(), v8::Number::New(isolate, nodes[i].id)); checked = obj->DefineOwnProperty( context, v8::String::NewFromUtf8(isolate, "start").ToLocalChecked(), v8::Number::New(isolate, nodes[i].text_start)); checked = obj->DefineOwnProperty( context, v8::String::NewFromUtf8(isolate, "length").ToLocalChecked(), v8::Number::New(isolate, (nodes[i].text_end - nodes[i].text_start))); checked = highlight_array->Set(isolate->GetCurrentContext(), i, obj); } return highlight_array; } v8::Local ReadAnythingAppController::GetHighlightForCurrentSegmentIndex(int index, bool phrases) { v8::Isolate* isolate = render_frame()->GetWebFrame()->GetAgentGroupScheduler()->Isolate(); auto context = isolate->GetCurrentContext(); std::vector nodes = read_aloud_model_.GetHighlightForCurrentSegmentIndex(index, phrases); v8::Local highlight_array = v8::Array::New(isolate, nodes.size()); for (int i = 0; i < (int)nodes.size(); i++) { v8::Local obj = v8::Object::New(isolate); auto checked = obj->DefineOwnProperty( context, v8::String::NewFromUtf8(isolate, "nodeId").ToLocalChecked(), v8::Number::New(isolate, nodes[i].id)); checked = obj->DefineOwnProperty( context, v8::String::NewFromUtf8(isolate, "start").ToLocalChecked(), v8::Number::New(isolate, nodes[i].text_start)); checked = obj->DefineOwnProperty( context, v8::String::NewFromUtf8(isolate, "length").ToLocalChecked(), v8::Number::New(isolate, (nodes[i].text_end - nodes[i].text_start))); checked = highlight_array->Set(isolate->GetCurrentContext(), i, obj); } return highlight_array; } void ReadAnythingAppController::IncrementMetricCount( const std::string& metric) { read_aloud_model_.IncrementMetric(metric); } void ReadAnythingAppController::LogSpeechStop(int source) { // Don't log speech stopping if the reading mode panel is going to hide. That // case is logged separately. if (model_.will_hide()) { return; } if (const auto maybe_enum = ToEnum(source)) { read_aloud_model_.LogSpeechStop(maybe_enum.value()); } } void ReadAnythingAppController::RecordSessionMetricsIfShownOrRecentlyHidden( bool just_hidden) { // Don't log session metrics if reading mode is hidden unless it is known // that it was just hidden. if (!just_hidden && IsHidden()) { return; } // Ensure distillation metrics are logged if reading mode closes prematurely. if (distillation_status_logging_delay_timer_.IsRunning()) { distillation_status_logging_delay_timer_.Stop(); RecordScreen2xDistillationStatus(just_hidden); } LogPageDuration(); LogLineFocusSession(); RecordNumSelections(); RecordEstimatedWordsHeard(); RecordEstimatedWordsSeen(); read_aloud_model_.ResetAndLogSingleSampleMetrics(); } void ReadAnythingAppController::StartLineFocusSession() { if (IsLineFocusEnabled()) { model_.set_line_focus_session_start_time(base::TimeTicks::Now()); } } void ReadAnythingAppController::LogLineFocusSession() { if (IsLineFocusEnabled() && model_.line_focus_session_start_time().has_value()) { base::UmaHistogramLongTimes( "Accessibility.ReadAnything.LineFocusSessionLength", base::TimeTicks::Now() - model_.line_focus_session_start_time().value()); base::UmaHistogramCounts1M( "Accessibility.ReadAnything.LineFocusSessionMouseDistance", model_.line_focus_mouse_distance()); base::UmaHistogramCounts1M( "Accessibility.ReadAnything.LineFocusSessionScrollDistance", model_.line_focus_scroll_distance()); base::UmaHistogramCounts100000( "Accessibility.ReadAnything.LineFocusSessionKeyboardLines", model_.line_focus_keyboard_lines()); base::UmaHistogramCounts100000( "Accessibility.ReadAnything.LineFocusSessionSpeechLines", model_.line_focus_speech_lines()); model_.ResetLineFocusSession(); } } void ReadAnythingAppController::LogPageDuration() { if (!model_.page_start_time().has_value()) { return; } base::TimeDelta duration = base::TimeTicks::Now() - model_.page_start_time().value(); model_.set_page_start_time(std::nullopt); std::string page_type = model_.is_pdf() ? "Pdf" : "WebPage"; std::string view_mode = (model_.active_presentation_state() == read_anything::mojom::ReadAnythingPresentationState::kInImmersiveOverlay) ? "FullPage" : "SidePanel"; std::string histogram_name = absl::StrFormat("Accessibility.ReadAnything.PageDuration.%sIn%s", page_type.c_str(), view_mode.c_str()); base::UmaHistogramCustomTimes(histogram_name, duration, base::Seconds(1), base::Hours(24), /*buckets=*/100); } void ReadAnythingAppController::AddLineFocusScrollDistance(int distance) { if (IsLineFocusEnabled()) { model_.set_line_focus_scroll_distance(model_.line_focus_scroll_distance() + distance); } } void ReadAnythingAppController::AddLineFocusMouseDistance(int distance) { if (IsLineFocusEnabled()) { model_.set_line_focus_mouse_distance(model_.line_focus_mouse_distance() + distance); } } void ReadAnythingAppController::IncrementLineFocusKeyboardLines() { if (IsLineFocusEnabled()) { model_.set_line_focus_keyboard_lines(model_.line_focus_keyboard_lines() + 1); } } void ReadAnythingAppController::IncrementLineFocusSpeechLines() { if (IsLineFocusEnabled()) { model_.set_line_focus_speech_lines(model_.line_focus_speech_lines() + 1); } } void ReadAnythingAppController::OnUrlInformationSet() { read_aloud_model_.LogSpeechStop( model_.IsReload() ? ReadAloudAppModel::ReadAloudStopSource::kReloadPage : ReadAloudAppModel::ReadAloudStopSource::kChangePage); } void ReadAnythingAppController::OnScrolledToBottom() { if (IsGoogleDocs()) { // Scroll to the last display node shown on the Reading Mode side panel // TODO (b/356935604): Investigate optimal scroll position page_handler_->ScrollToTargetNode( model_.active_tree_id(), *model_.GetCurrentlyVisibleNodes()->rbegin()); } } bool ReadAnythingAppController::IsDocsLoadMoreButtonVisible() const { return (features::IsReadAnythingDocsLoadMoreButtonEnabled() && IsGoogleDocs()); } void ReadAnythingAppController::UpdateDependencyParserModel( base::File model_file) { read_aloud_model_.GetDependencyParserModel() .AsyncCall(&DependencyParserModel::UpdateWithFile) .WithArgs(std::move(model_file)); } base::SequenceBound& ReadAnythingAppController::GetDependencyParserModelForTesting() { return read_aloud_model_.GetDependencyParserModel(); } void ReadAnythingAppController::OnTreeAdded(ui::AXTree* tree) { auto observation = std::make_unique>( this); observation->Observe(tree); tree_observers_.push_back(std::move(observation)); } void ReadAnythingAppController::OnTreeRemoved(ui::AXTree* tree) { auto it = std::ranges::find_if(tree_observers_, [tree](const auto& observation) -> bool { return observation->GetSource() == tree; }); if (it != tree_observers_.end()) { tree_observers_.erase(it); } } std::string ReadAnythingAppController::GetDomDistillerTitle() const { return dom_distiller_title_; } std::string ReadAnythingAppController::GetDomDistillerContentHtml() const { return dom_distiller_content_html_; } v8::Local ReadAnythingAppController::GetDomDistillerAnchors() const { v8::Isolate* isolate = v8::Isolate::GetCurrent(); if (!IsReadabilityEnabled() || !isolate) { return v8::Undefined(isolate); } v8::EscapableHandleScope handle_scope(isolate); v8::Local context = isolate->GetCurrentContext(); if (context.IsEmpty()) { return v8::Undefined(isolate); } v8::Local result_obj = v8::Object::New(isolate); auto anchors = model_.ax_tree_anchors(); for (const auto& [url, link_data_list] : anchors) { v8::Local v8_array = v8::Array::New(isolate, static_cast(link_data_list.size())); for (size_t i = 0; i < link_data_list.size(); ++i) { const auto& data = link_data_list[i]; v8::Local link_obj = v8::Object::New(isolate); gin::Dictionary link_dict(isolate, link_obj); link_dict.Set("axId", data.id); if (!data.html_id.empty()) { link_dict.Set("htmlId", data.html_id); } if (!data.target.empty()) { link_dict.Set("target", data.target); } if (!data.title.empty()) { link_dict.Set("title", data.title); } if (!data.name.empty()) { link_dict.Set("text", data.name); } if (!data.text_before.empty()) { link_dict.Set("textBefore", data.text_before); } if (!data.text_after.empty()) { link_dict.Set("textAfter", data.text_after); } v8_array->Set(context, static_cast(i), link_obj).Check(); } result_obj->Set(context, gin::StringToV8(isolate, url), v8_array).Check(); } return handle_scope.Escape(result_obj); } void ReadAnythingAppController::UpdateContent(const std::string& title, const std::string& content) { if (!features::IsReadAnythingWithReadabilityEnabled()) { return; } dom_distiller_title_ = title; dom_distiller_content_html_ = content; // If readability distillation returns empty content, consider distillation as // failure and default to Screen2X distillation. if (dom_distiller_content_html_.empty()) { model_.set_next_distillation_method( ReadAnythingAppModel::DistillationMethod::kScreen2x); // Immediately attempt distillation. If there's not yet an active tree, // distillation will be attempted after the event processes. However, // attempting distillation immediately will allow distillation failures // to register. model_.set_requires_distillation(true); DistillNewTree(); return; } // If speech is playing, don't redraw and disrupt speech. The app will // re-distill once speech pauses. // TODO(b/550352614): Refactor this to use IsUpdateProcessingPaused() and set // the state to kDistillationWithContent, bringing Readability into parity // with Screen2x distillation PostProcessing. This needs to have it's own test // to check that the state is set correctly and the pending distillations are // executed. if (features::IsReadAnythingImprovedUiEnabled() && read_aloud_model_.speech_playing()) { model_.set_requires_readability_distillation(true); VLOG(1) << "Distillation terminated because speech is playing"; return; } model_.set_readability_distillation_complete_for_current_tree(true); // Set both active and target distillation to readability since distillation // was successful. model_.set_next_distillation_method( ReadAnythingAppModel::DistillationMethod::kReadability); model_.set_current_content_distillation_method( ReadAnythingAppModel::DistillationMethod::kReadability); if (IsReadabilitySelectTextEnabled()) { // Reset text blocks when content is updated and reset should map flag to // not trigger a false positive when rendered text is not ready. model_.set_readability_text_blocks({}); model_.set_should_map_rendered_text_to_tree_for_readability(false); model_.set_is_readability_mapping_in_progress(true); } ExecuteJavaScript("chrome.readingMode.updateContent();"); if (IsReadabilitySelectTextEnabled() && !IsUpdateProcessingPaused() && model_.ContainsActiveTree()) { PostProcessSelection(); } model_.set_should_extract_anchors_from_tree_for_readability(true); bool didProcessAnchors = model_.ProcessAXTreeAnchors(); if (didProcessAnchors) { ExecuteJavaScript("chrome.readingMode.onAnchorsReadyForReadability();"); } // Log a successful readability distillation if reading mode is currently // open. If it is hidden/closed, defer logging until it is reopened. if (!IsHidden()) { RecordDistillationStatus( read_anything::mojom::DistillationStatus::kSuccess); } } void ReadAnythingAppController::OnReadabilityDistillationStateChanged( read_anything::mojom::ReadAnythingDistillationState new_state) { // Readability distillation happens in the browser // (ReadAnythingUntrustedPageHandler). This notification triggers a // "ping-pong" flow to keep logic synchronized: it updates the renderer's // model, which then circles back to the ReadAnythingUntrustedPageHandler to // update the distillation state in the ReadAnythingController. SetDistillationState(new_state); } void ReadAnythingAppController::OnMainFrameSameDocumentNavigation( const GURL& url) { std::string script = base::StrCat({"chrome.readingMode.onMainFrameSameDocumentNavigation(", base::GetQuotedJSONString(url.spec()), ");"}); ExecuteJavaScript(script); } void ReadAnythingAppController::ApplyAccessibilityUpdatesForReadability( const ui::AXTreeID& tree_id, const std::vector& updates, const std::vector& events) { model_.ApplyAccessibilityUpdates( tree_id, const_cast&>(updates), const_cast&>(events)); // If the tree is not ready, ProcessAXTreeAnchors and MapRenderedTextToTree // will do an early return and wait for the next update until they are able to // process the tree. bool didProcessAnchors = model_.ProcessAXTreeAnchors(); if (didProcessAnchors) { ExecuteJavaScript("chrome.readingMode.onAnchorsReadyForReadability();"); } // Ignore updates from non-active trees. if (tree_id != model_.active_tree_id()) { return; } // If there's been a selection on the main page, the selection should be // processed so that Immersive can open to the correctly selected text. if (IsReadabilitySelectTextEnabled() && model_.requires_post_process_selection()) { // TODO: crbug.com/505770261- Once general select-to-distill is enabled // this should be re-evaluated to prevent switching distillation modes // before the selection mapping is ready. PostProcessSelection(); } // Check if we should perform text mapping for readability text selection. MaybeMapRenderedTextToTree(); } void ReadAnythingAppController::OnRenderedTextBlocksAvailable( const std::vector& blocks) { if (!rendered_text_blocks_ready_recorded_) { DCHECK(!active_tree_changed_start_time_.is_null()); base::TimeDelta elapsed_time = base::TimeTicks::Now() - active_tree_changed_start_time_; base::UmaHistogramLongTimes( "Accessibility.ReadAnything." "TimeFromActiveAXTreeIDChangedToRenderedTextBlocks", elapsed_time); rendered_text_blocks_ready_recorded_ = true; } if (!IsReadabilitySelectTextEnabled()) { return; } model_.set_readability_text_blocks(blocks); model_.set_should_map_rendered_text_to_tree_for_readability(true); // Check if we should perform text mapping for readability text selection. MaybeMapRenderedTextToTree(); } void ReadAnythingAppController::MaybeMapRenderedTextToTree() { if (!IsReadabilitySelectTextEnabled()) { return; } // Only attempt mapping if we have text blocks from the WebUI. if (model_.readability_text_blocks().empty()) { return; } if (model_.MapRenderedTextToTree(model_.readability_text_blocks())) { model_.set_is_readability_mapping_in_progress(false); ExecuteJavaScript("chrome.readingMode.onRenderedTextMappingReady();"); } } v8::Local ReadAnythingAppController::GetAXMapping(int index) { v8::Isolate* isolate = v8::Isolate::GetCurrent(); if (!IsReadabilitySelectTextEnabled() || !isolate) { return v8::Undefined(isolate); } v8::EscapableHandleScope handle_scope(isolate); v8::Local context = isolate->GetCurrentContext(); if (context.IsEmpty()) { return v8::Undefined(isolate); } // Retrieve the mapping segments from the model for the given block index. // A single Readability block can map to multiple AXNodes (e.g. if it contains // inline links). std::vector segments = model_.GetAXMapping(static_cast(index)); v8::Local v8_segments = v8::Array::New(isolate, static_cast(segments.size())); for (size_t i = 0; i < segments.size(); ++i) { const auto& segment = segments[i]; // Create a V8 object for this segment and populate it with the source // AXNode ID and the start/end character offsets within the distilled block. v8::Local segment_obj = v8::Object::New(isolate); gin::Dictionary segment_dict(isolate, segment_obj); segment_dict.Set("axNodeId", segment.id); segment_dict.Set("start", segment.start); segment_dict.Set("end", segment.end); segment_dict.Set("axNodeOffset", segment.ax_node_offset); v8_segments->Set(context, static_cast(i), segment_obj).Check(); } return handle_scope.Escape(v8_segments); } void ReadAnythingAppController::AttemptLogEarlySelection(bool from_side_panel) { if (model_.has_logged_early_selection() || !model_.is_readability_mapping_in_progress() || !IsReadabilitySelectTextEnabled()) { return; } model_.set_has_logged_early_selection(true); base::UmaHistogramEnumeration( ReadAnythingAppModel::kEarlySelectionHistogramName, from_side_panel ? ReadAnythingAppModel::EarlySelection::kSidePanelSelection : ReadAnythingAppModel::EarlySelection::kMainPanelSelection); } bool ReadAnythingAppController::IsHidden() const { return IsImmersiveEnabled() && !model_.is_active_presentation_state_opened(); }