| // Copyright 2016 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/android/vr/vr_shell.h" |
| |
| #include <android/native_window_jni.h> |
| |
| #include <algorithm> |
| #include <string> |
| #include <utility> |
| |
| #include "base/android/jni_string.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/threading/platform_thread.h" |
| #include "base/threading/thread.h" |
| #include "base/threading/thread_restrictions.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "base/trace_event/trace_event.h" |
| #include "base/values.h" |
| #include "chrome/browser/android/chrome_feature_list.h" |
| #include "chrome/browser/android/tab_android.h" |
| #include "chrome/browser/android/vr/android_ui_gesture_target.h" |
| #include "chrome/browser/android/vr/autocomplete_controller.h" |
| #include "chrome/browser/android/vr/vr_gl_thread.h" |
| #include "chrome/browser/android/vr/vr_input_connection.h" |
| #include "chrome/browser/android/vr/vr_shell_delegate.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/component_updater/vr_assets_component_installer.h" |
| #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h" |
| #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h" |
| #include "chrome/browser/permissions/permission_manager.h" |
| #include "chrome/browser/permissions/permission_result.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/profiles/profile_manager.h" |
| #include "chrome/browser/ssl/security_state_tab_helper.h" |
| #include "chrome/browser/vr/assets_loader.h" |
| #include "chrome/browser/vr/browser_renderer.h" |
| #include "chrome/browser/vr/metrics/metrics_helper.h" |
| #include "chrome/browser/vr/metrics/session_metrics_helper.h" |
| #include "chrome/browser/vr/model/assets.h" |
| #include "chrome/browser/vr/model/omnibox_suggestions.h" |
| #include "chrome/browser/vr/model/text_input_info.h" |
| #include "chrome/browser/vr/toolbar_helper.h" |
| #include "chrome/browser/vr/ui_test_input.h" |
| #include "chrome/browser/vr/vr_tab_helper.h" |
| #include "chrome/browser/vr/vr_web_contents_observer.h" |
| #include "chrome/common/chrome_features.h" |
| #include "chrome/common/pref_names.h" |
| #include "chrome/common/url_constants.h" |
| #include "components/prefs/pref_service.h" |
| #include "content/public/browser/browser_context.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/navigation_controller.h" |
| #include "content/public/browser/navigation_entry.h" |
| #include "content/public/browser/render_process_host.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/browser/render_widget_host.h" |
| #include "content/public/browser/render_widget_host_iterator.h" |
| #include "content/public/browser/render_widget_host_view.h" |
| #include "content/public/browser/storage_partition.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/referrer.h" |
| #include "content/public/common/service_manager_connection.h" |
| #include "content/public/common/url_constants.h" |
| #include "device/vr/android/gvr/cardboard_gamepad_data_fetcher.h" |
| #include "device/vr/android/gvr/gvr_device.h" |
| #include "device/vr/android/gvr/gvr_gamepad_data_fetcher.h" |
| #include "gpu/command_buffer/common/mailbox.h" |
| #include "jni/VrShell_jni.h" |
| #include "services/device/public/mojom/constants.mojom.h" |
| #include "services/network/public/cpp/shared_url_loader_factory.h" |
| #include "services/service_manager/public/cpp/connector.h" |
| #include "ui/android/window_android.h" |
| #include "ui/base/page_transition_types.h" |
| #include "ui/display/display.h" |
| #include "ui/display/screen.h" |
| #include "ui/gfx/android/java_bitmap.h" |
| #include "ui/gfx/codec/png_codec.h" |
| #include "ui/gfx/geometry/point_f.h" |
| #include "ui/gfx/geometry/size.h" |
| #include "ui/gfx/geometry/size_conversions.h" |
| #include "ui/gl/android/surface_texture.h" |
| #include "url/gurl.h" |
| |
| using base::android::JavaParamRef; |
| using base::android::ScopedJavaLocalRef; |
| |
| namespace vr { |
| |
| namespace { |
| vr::VrShell* g_vr_shell_instance; |
| |
| constexpr base::TimeDelta kPollCapturingStateInterval = |
| base::TimeDelta::FromSecondsD(0.2); |
| |
| constexpr base::TimeDelta kAssetsComponentWaitDelay = |
| base::TimeDelta::FromSeconds(2); |
| |
| static constexpr float kInchesToMeters = 0.0254f; |
| // Screen pixel density of the Google Pixel phone in pixels per inch. |
| static constexpr float kPixelPpi = 441.0f; |
| // Screen pixel density of the Google Pixel phone in pixels per meter. |
| static constexpr float kPixelPpm = kPixelPpi / kInchesToMeters; |
| |
| // Factor to adjust the legibility of the content. Making this factor smaller |
| // increases the text size. |
| static constexpr float kContentLegibilityFactor = 1.36f; |
| |
| // This factor converts the physical width of the projected |
| // content quad into the required width of the virtual content window. |
| // TODO(tiborg): This value is calibrated for the Google Pixel. We should adjust |
| // this value dynamically based on the target device's pixel density in the |
| // future. |
| static constexpr float kContentBoundsMetersToWindowSize = |
| kPixelPpm * kContentLegibilityFactor; |
| |
| // Factor by which the content's pixel amount is increased beyond what the |
| // projected content quad covers in screen real estate. |
| // This DPR factor works well on Pixel phones. |
| static constexpr float kContentDprFactor = 4.0f; |
| |
| void SetIsInVR(content::WebContents* contents, bool is_in_vr) { |
| if (contents && contents->GetRenderWidgetHostView()) { |
| // TODO(asimjour) Contents should not be aware of VR mode. Instead, we |
| // should add a flag for disabling specific UI such as the keyboard (see |
| // VrTabHelper for details). |
| contents->GetRenderWidgetHostView()->SetIsInVR(is_in_vr); |
| |
| VrTabHelper* vr_tab_helper = VrTabHelper::FromWebContents(contents); |
| DCHECK(vr_tab_helper); |
| vr_tab_helper->SetIsInVr(is_in_vr); |
| } |
| } |
| |
| } // namespace |
| |
| VrShell::VrShell(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| const UiInitialState& ui_initial_state, |
| VrShellDelegate* delegate, |
| gvr_context* gvr_api, |
| bool reprojected_rendering, |
| float display_width_meters, |
| float display_height_meters, |
| int display_width_pixels, |
| int display_height_pixels, |
| bool pause_content, |
| bool low_density) |
| : web_vr_autopresentation_expected_( |
| ui_initial_state.web_vr_autopresentation_expected), |
| delegate_provider_(delegate), |
| main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
| reprojected_rendering_(reprojected_rendering), |
| display_size_meters_(display_width_meters, display_height_meters), |
| display_size_pixels_(display_width_pixels, display_height_pixels), |
| gl_surface_created_event_( |
| base::WaitableEvent::ResetPolicy::MANUAL, |
| base::WaitableEvent::InitialState::NOT_SIGNALED), |
| weak_ptr_factory_(this) { |
| DVLOG(1) << __FUNCTION__ << "=" << this; |
| DCHECK(g_vr_shell_instance == nullptr); |
| g_vr_shell_instance = this; |
| j_vr_shell_.Reset(env, obj); |
| |
| base::OnceCallback<gfx::AcceleratedWidget()> surface_callback = |
| base::BindOnce(&VrShell::GetRenderSurface, base::Unretained(this)); |
| |
| gl_thread_ = std::make_unique<VrGLThread>( |
| weak_ptr_factory_.GetWeakPtr(), main_thread_task_runner_, gvr_api, |
| ui_initial_state, reprojected_rendering_, HasDaydreamSupport(env), |
| pause_content, low_density, &gl_surface_created_event_, |
| std::move(surface_callback)); |
| ui_ = gl_thread_.get(); |
| toolbar_ = std::make_unique<ToolbarHelper>(ui_, this); |
| autocomplete_controller_ = |
| std::make_unique<AutocompleteController>(base::BindRepeating( |
| &BrowserUiInterface::SetOmniboxSuggestions, base::Unretained(ui_))); |
| |
| gl_thread_->Start(); |
| |
| if (ui_initial_state.in_web_vr || |
| ui_initial_state.web_vr_autopresentation_expected) { |
| UMA_HISTOGRAM_BOOLEAN("VRAutopresentedWebVR", |
| ui_initial_state.web_vr_autopresentation_expected); |
| } |
| |
| can_load_new_assets_ = AssetsLoader::GetInstance()->ComponentReady(); |
| if (!can_load_new_assets_) { |
| waiting_for_assets_component_timer_.Start( |
| FROM_HERE, kAssetsComponentWaitDelay, |
| base::BindRepeating(&VrShell::OnAssetsComponentWaitTimeout, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| AssetsLoader::GetInstance()->SetOnComponentReadyCallback(base::BindRepeating( |
| &VrShell::OnAssetsComponentReady, weak_ptr_factory_.GetWeakPtr())); |
| AssetsLoader::GetInstance()->GetMetricsHelper()->OnEnter(Mode::kVr); |
| |
| UpdateVrAssetsComponent(g_browser_process->component_updater()); |
| |
| auto* connector = |
| content::ServiceManagerConnection::GetForProcess()->GetConnector(); |
| connector->BindInterface(device::mojom::kServiceName, &geolocation_config_); |
| } |
| |
| void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) { |
| delete this; |
| } |
| |
| bool VrShell::HasUiFinishedLoading( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj) { |
| return ui_finished_loading_; |
| } |
| |
| void VrShell::SwapContents(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| const JavaParamRef<jobject>& tab) { |
| content_id_++; |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::OnSwapContents, |
| gl_thread_->GetBrowserRenderer(), content_id_)); |
| TabAndroid* active_tab = |
| tab.is_null() |
| ? nullptr |
| : TabAndroid::GetNativeTab(env, JavaParamRef<jobject>(env, tab)); |
| |
| content::WebContents* contents = |
| active_tab ? active_tab->web_contents() : nullptr; |
| bool is_native_page = active_tab ? active_tab->IsNativePage() : true; |
| |
| SetIsInVR(GetNonNativePageWebContents(), false); |
| |
| web_contents_ = contents; |
| web_contents_is_native_page_ = is_native_page; |
| SetIsInVR(GetNonNativePageWebContents(), true); |
| SetUiState(); |
| |
| if (web_contents_) { |
| vr_input_connection_.reset(new VrInputConnection(web_contents_)); |
| PostToGlThread(FROM_HERE, base::BindOnce(&VrGLThread::SetInputConnection, |
| base::Unretained(gl_thread_.get()), |
| vr_input_connection_.get())); |
| } else { |
| vr_input_connection_ = nullptr; |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&VrGLThread::SetInputConnection, |
| base::Unretained(gl_thread_.get()), nullptr)); |
| } |
| |
| vr_web_contents_observer_ = std::make_unique<VrWebContentsObserver>( |
| web_contents_, ui_, toolbar_.get(), |
| base::BindOnce(&VrShell::ContentWebContentsDestroyed, |
| base::Unretained(this))); |
| |
| // TODO(https://crbug.com/684661): Make SessionMetricsHelper tab-aware and |
| // able to track multiple tabs. |
| if (web_contents_ && !SessionMetricsHelper::FromWebContents(web_contents_)) { |
| SessionMetricsHelper::CreateForWebContents( |
| web_contents_, |
| webvr_mode_ ? Mode::kWebXrVrPresentation : Mode::kVrBrowsingRegular, |
| web_vr_autopresentation_expected_); |
| } |
| } |
| |
| void VrShell::SetAndroidGestureTarget( |
| JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| const JavaParamRef<jobject>& android_ui_gesture_target) { |
| android_ui_gesture_target_.reset( |
| AndroidUiGestureTarget::FromJavaObject(android_ui_gesture_target)); |
| } |
| |
| void VrShell::SetDialogGestureTarget( |
| JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| const JavaParamRef<jobject>& dialog_gesture_target) { |
| dialog_gesture_target_.reset( |
| AndroidUiGestureTarget::FromJavaObject(dialog_gesture_target)); |
| } |
| |
| void VrShell::SetUiState() { |
| toolbar_->Update(); |
| |
| if (!GetNonNativePageWebContents()) { |
| ui_->SetLoading(false); |
| ui_->SetFullscreen(false); |
| } else { |
| ui_->SetLoading(GetNonNativePageWebContents()->IsLoading()); |
| ui_->SetFullscreen(GetNonNativePageWebContents()->IsFullscreen()); |
| } |
| if (web_contents_) { |
| ui_->SetIncognito(web_contents_->GetBrowserContext()->IsOffTheRecord()); |
| } else { |
| ui_->SetIncognito(false); |
| } |
| } |
| |
| VrShell::~VrShell() { |
| DVLOG(1) << __FUNCTION__ << "=" << this; |
| content_surface_texture_ = nullptr; |
| overlay_surface_texture_ = nullptr; |
| if (gvr_gamepad_source_active_) { |
| device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory( |
| device::GAMEPAD_SOURCE_GVR); |
| } |
| |
| if (cardboard_gamepad_source_active_) { |
| device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory( |
| device::GAMEPAD_SOURCE_CARDBOARD); |
| } |
| |
| delegate_provider_->RemoveDelegate(); |
| { |
| // The GvrLayout is, and must always be, used only on the UI thread, and the |
| // GvrApi used for rendering should only be used from the GL thread as it's |
| // not thread safe. However, the GvrLayout owns the GvrApi instance, and |
| // when it gets shut down it deletes the GvrApi instance with it. Therefore, |
| // we need to block shutting down the GvrLayout on stopping our GL thread |
| // from using the GvrApi instance. |
| // base::Thread::Stop, which is called when destroying the thread, asserts |
| // that IO is allowed to prevent jank, but there shouldn't be any concerns |
| // regarding jank in this case, because we're switching from 3D to 2D, |
| // adding/removing a bunch of Java views, and probably changing device |
| // orientation here. |
| base::ThreadRestrictions::ScopedAllowIO allow_io; |
| gl_thread_.reset(); |
| } |
| g_vr_shell_instance = nullptr; |
| } |
| |
| void VrShell::PostToGlThread(const base::Location& from_here, |
| base::OnceClosure task) { |
| gl_thread_->task_runner()->PostTask(from_here, std::move(task)); |
| } |
| |
| void VrShell::Navigate(GURL url, NavigationMethod method) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| |
| // Record metrics. |
| if (method == NavigationMethod::kOmniboxSuggestionSelected || |
| method == NavigationMethod::kOmniboxUrlEntry) { |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) |
| metrics_helper->RecordUrlRequested(url, method); |
| } |
| |
| Java_VrShell_loadUrl(env, j_vr_shell_, |
| base::android::ConvertUTF8ToJavaString(env, url.spec())); |
| } |
| |
| void VrShell::NavigateBack() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_navigateBack(env, j_vr_shell_); |
| } |
| |
| void VrShell::NavigateForward() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_navigateForward(env, j_vr_shell_); |
| } |
| |
| void VrShell::ReloadTab() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_reloadTab(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenNewTab(bool incognito) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openNewTab(env, j_vr_shell_, incognito); |
| } |
| |
| void VrShell::SelectTab(int id, bool incognito) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_selectTab(env, j_vr_shell_, id, incognito); |
| } |
| |
| void VrShell::OpenBookmarks() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openBookmarks(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenRecentTabs() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openRecentTabs(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenHistory() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openHistory(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenDownloads() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openDownloads(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenShare() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openShare(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenSettings() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openSettings(env, j_vr_shell_); |
| } |
| |
| void VrShell::CloseTab(int id, bool incognito) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_closeTab(env, j_vr_shell_, id, incognito); |
| } |
| |
| void VrShell::CloseAllTabs() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_closeAllTabs(env, j_vr_shell_); |
| } |
| |
| void VrShell::CloseAllIncognitoTabs() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_closeAllIncognitoTabs(env, j_vr_shell_); |
| } |
| |
| void VrShell::OpenFeedback() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_openFeedback(env, j_vr_shell_); |
| } |
| |
| void VrShell::CloseHostedDialog() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_closeCurrentDialog(env, j_vr_shell_); |
| } |
| |
| void VrShell::ToggleCardboardGamepad(bool enabled) { |
| // Enable/disable updating gamepad state. |
| if (cardboard_gamepad_source_active_ && !enabled) { |
| device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory( |
| device::GAMEPAD_SOURCE_CARDBOARD); |
| cardboard_gamepad_data_fetcher_ = nullptr; |
| cardboard_gamepad_source_active_ = false; |
| } |
| |
| if (!cardboard_gamepad_source_active_ && enabled) { |
| device::GvrDevice* device = delegate_provider_->GetDevice(); |
| if (!device) |
| return; |
| |
| device::GamepadDataFetcherManager::GetInstance()->AddFactory( |
| new device::CardboardGamepadDataFetcher::Factory(this, |
| device->GetId())); |
| cardboard_gamepad_source_active_ = true; |
| if (pending_cardboard_trigger_) { |
| OnTriggerEvent(nullptr, JavaParamRef<jobject>(nullptr), true); |
| } |
| pending_cardboard_trigger_ = false; |
| } |
| } |
| |
| void VrShell::ToggleGvrGamepad(bool enabled) { |
| // Enable/disable updating gamepad state. |
| if (enabled) { |
| DCHECK(!gvr_gamepad_source_active_); |
| device::GvrDevice* device = delegate_provider_->GetDevice(); |
| if (!device) |
| return; |
| |
| device::GamepadDataFetcherManager::GetInstance()->AddFactory( |
| new device::GvrGamepadDataFetcher::Factory(this, device->GetId())); |
| gvr_gamepad_source_active_ = true; |
| } else { |
| DCHECK(gvr_gamepad_source_active_); |
| device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory( |
| device::GAMEPAD_SOURCE_GVR); |
| gvr_gamepad_data_fetcher_ = nullptr; |
| gvr_gamepad_source_active_ = false; |
| } |
| } |
| |
| void VrShell::OnTriggerEvent(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| bool touched) { |
| // If we are running cardboard, update gamepad state. |
| if (cardboard_gamepad_source_active_) { |
| device::CardboardGamepadData pad; |
| pad.timestamp = cardboard_gamepad_timer_++; |
| pad.is_screen_touching = touched; |
| if (cardboard_gamepad_data_fetcher_) { |
| cardboard_gamepad_data_fetcher_->SetGamepadData(pad); |
| } |
| } else { |
| pending_cardboard_trigger_ = touched; |
| } |
| |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::OnTriggerEvent, |
| gl_thread_->GetBrowserRenderer(), touched)); |
| } |
| |
| void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) { |
| PostToGlThread(FROM_HERE, base::BindOnce(&BrowserRenderer::OnPause, |
| gl_thread_->GetBrowserRenderer())); |
| |
| // exit vr session |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) |
| metrics_helper->SetVRActive(false); |
| SetIsInVR(GetNonNativePageWebContents(), false); |
| |
| poll_capturing_state_task_.Cancel(); |
| } |
| |
| void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) { |
| // Calling WaitForAssets before BrowserRenderer::OnResume so that the UI won't |
| // accidentally produce an initial frame with UI. |
| if (can_load_new_assets_) { |
| ui_->WaitForAssets(); |
| LoadAssets(); |
| } |
| |
| PostToGlThread(FROM_HERE, base::BindOnce(&BrowserRenderer::OnResume, |
| gl_thread_->GetBrowserRenderer())); |
| |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) |
| metrics_helper->SetVRActive(true); |
| SetIsInVR(GetNonNativePageWebContents(), true); |
| |
| PollCapturingState(); |
| } |
| |
| void VrShell::SetSurface(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| const JavaParamRef<jobject>& surface) { |
| DCHECK(!reprojected_rendering_); |
| DCHECK(!surface.is_null()); |
| gfx::AcceleratedWidget window = |
| ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface); |
| surface_window_ = window; |
| gl_surface_created_event_.Signal(); |
| } |
| |
| void VrShell::SetWebVrMode(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| bool enabled) { |
| webvr_mode_ = enabled; |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) |
| metrics_helper->SetWebVREnabled(enabled); |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::SetWebXrMode, |
| gl_thread_->GetBrowserRenderer(), enabled)); |
| // We create and dispose a page info in order to get notifed of page |
| // permissions. |
| CreatePageInfo(); |
| ui_->SetWebVrMode(enabled); |
| |
| if (!webvr_mode_ && !web_vr_autopresentation_expected_) { |
| AssetsLoader::GetInstance()->GetMetricsHelper()->OnEnter(Mode::kVrBrowsing); |
| } else { |
| AssetsLoader::GetInstance()->GetMetricsHelper()->OnEnter( |
| Mode::kWebXrVrPresentation); |
| } |
| } |
| |
| bool VrShell::GetWebVrMode(JNIEnv* env, const JavaParamRef<jobject>& obj) { |
| return webvr_mode_; |
| } |
| |
| bool VrShell::IsDisplayingUrlForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj) { |
| return ShouldDisplayURL(); |
| } |
| |
| base::android::ScopedJavaLocalRef<jobject> |
| VrShell::GetVrInputConnectionForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj) { |
| if (!vr_input_connection_) |
| return nullptr; |
| |
| return vr_input_connection_->GetJavaObject(); |
| } |
| |
| void VrShell::OnLoadProgressChanged(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| double progress) { |
| ui_->SetLoadProgress(progress); |
| } |
| |
| void VrShell::OnTabListCreated(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| jobjectArray tabs, |
| jobjectArray incognito_tabs) { |
| ui_->RemoveAllTabs(); |
| size_t len = env->GetArrayLength(incognito_tabs); |
| for (size_t i = 0; i < len; ++i) { |
| ScopedJavaLocalRef<jobject> j_tab( |
| env, env->GetObjectArrayElement(incognito_tabs, i)); |
| TabAndroid* tab = TabAndroid::GetNativeTab(env, j_tab); |
| ui_->AddOrUpdateTab(tab->GetAndroidId(), true, tab->GetTitle()); |
| } |
| |
| len = env->GetArrayLength(tabs); |
| for (size_t i = 0; i < len; ++i) { |
| ScopedJavaLocalRef<jobject> j_tab(env, env->GetObjectArrayElement(tabs, i)); |
| TabAndroid* tab = TabAndroid::GetNativeTab(env, j_tab); |
| ui_->AddOrUpdateTab(tab->GetAndroidId(), false, tab->GetTitle()); |
| } |
| } |
| |
| void VrShell::OnTabUpdated(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| jboolean incognito, |
| jint id, |
| jstring jtitle) { |
| base::string16 title; |
| base::android::ConvertJavaStringToUTF16(env, jtitle, &title); |
| ui_->AddOrUpdateTab(id, incognito, title); |
| } |
| |
| void VrShell::OnTabRemoved(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| jboolean incognito, |
| jint id) { |
| ui_->RemoveTab(id, incognito); |
| } |
| |
| void VrShell::SetAlertDialog(JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| float width, |
| float height) { |
| PostToGlThread(FROM_HERE, base::BindOnce(&BrowserRenderer::EnableAlertDialog, |
| gl_thread_->GetBrowserRenderer(), |
| gl_thread_.get(), width, height)); |
| } |
| |
| void VrShell::CloseAlertDialog( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj) { |
| PostToGlThread(FROM_HERE, base::BindOnce(&BrowserRenderer::DisableAlertDialog, |
| gl_thread_->GetBrowserRenderer())); |
| // This will refresh our permissions after an alert is closed which should |
| // ensure that long press on the app button gives accurate results. |
| CreatePageInfo(); |
| } |
| |
| void VrShell::SetDialogBufferSize( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| int width, |
| int height) { |
| if (ui_surface_texture_) |
| ui_surface_texture_->SetDefaultBufferSize(width, height); |
| } |
| |
| void VrShell::SetAlertDialogSize( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| float width, |
| float height) { |
| PostToGlThread(FROM_HERE, base::BindOnce(&BrowserRenderer::SetAlertDialogSize, |
| gl_thread_->GetBrowserRenderer(), |
| width, height)); |
| } |
| |
| void VrShell::SetDialogLocation(JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| float x, |
| float y) { |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::SetDialogLocation, |
| gl_thread_->GetBrowserRenderer(), x, y)); |
| } |
| |
| void VrShell::SetDialogFloating(JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| bool floating) { |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::SetDialogFloating, |
| gl_thread_->GetBrowserRenderer(), floating)); |
| } |
| |
| void VrShell::ShowToast(JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| jstring jtext) { |
| base::string16 text; |
| base::android::ConvertJavaStringToUTF16(env, jtext, &text); |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::ShowToast, |
| gl_thread_->GetBrowserRenderer(), text)); |
| } |
| |
| void VrShell::CancelToast(JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj) { |
| PostToGlThread(FROM_HERE, base::BindOnce(&BrowserRenderer::CancelToast, |
| gl_thread_->GetBrowserRenderer())); |
| } |
| |
| void VrShell::ConnectPresentingService( |
| device::mojom::VRDisplayInfoPtr display_info, |
| device::mojom::XRRuntimeSessionOptionsPtr options) { |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::ConnectPresentingService, |
| gl_thread_->GetBrowserRenderer(), |
| std::move(display_info), std::move(options))); |
| } |
| |
| void VrShell::SetHistoryButtonsEnabled(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| jboolean can_go_back, |
| jboolean can_go_forward) { |
| ui_->SetHistoryButtonsEnabled(can_go_back, can_go_forward); |
| } |
| |
| void VrShell::RequestToExitVr(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| int reason) { |
| ui_->ShowExitVrPrompt(static_cast<UiUnsupportedMode>(reason)); |
| } |
| |
| void VrShell::ContentSurfaceCreated(jobject surface, |
| gl::SurfaceTexture* texture) { |
| content_surface_texture_ = texture; |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| base::android::ScopedJavaGlobalRef<jobject> ref(env, surface); |
| Java_VrShell_contentSurfaceCreated(env, j_vr_shell_, ref); |
| } |
| |
| void VrShell::ContentOverlaySurfaceCreated(jobject surface, |
| gl::SurfaceTexture* texture) { |
| overlay_surface_texture_ = texture; |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| base::android::ScopedJavaGlobalRef<jobject> ref(env, surface); |
| Java_VrShell_contentOverlaySurfaceCreated(env, j_vr_shell_, ref); |
| } |
| |
| void VrShell::DialogSurfaceCreated(jobject surface, |
| gl::SurfaceTexture* texture) { |
| ui_surface_texture_ = texture; |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| base::android::ScopedJavaGlobalRef<jobject> ref(env, surface); |
| Java_VrShell_dialogSurfaceCreated(env, j_vr_shell_, ref); |
| } |
| |
| void VrShell::GvrDelegateReady(gvr::ViewerType viewer_type) { |
| delegate_provider_->SetDelegate(this, viewer_type); |
| } |
| |
| void VrShell::SendRequestPresentReply(device::mojom::XRSessionPtr session) { |
| delegate_provider_->SendRequestPresentReply(std::move(session)); |
| } |
| |
| void VrShell::BufferBoundsChanged(JNIEnv* env, |
| const JavaParamRef<jobject>& object, |
| jint content_width, |
| jint content_height, |
| jint overlay_width, |
| jint overlay_height) { |
| TRACE_EVENT0("gpu", "VrShell::ContentPhysicalBoundsChanged"); |
| if (content_surface_texture_) { |
| content_surface_texture_->SetDefaultBufferSize(content_width, |
| content_height); |
| } |
| if (overlay_surface_texture_) { |
| overlay_surface_texture_->SetDefaultBufferSize(overlay_width, |
| overlay_height); |
| } |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::BufferBoundsChanged, |
| gl_thread_->GetBrowserRenderer(), |
| gfx::Size(content_width, content_height), |
| gfx::Size(overlay_width, overlay_height))); |
| } |
| |
| void VrShell::ResumeContentRendering(JNIEnv* env, |
| const JavaParamRef<jobject>& object) { |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::ResumeContentRendering, |
| gl_thread_->GetBrowserRenderer())); |
| } |
| |
| void VrShell::OnOverlayTextureEmptyChanged(JNIEnv* env, |
| const JavaParamRef<jobject>& object, |
| jboolean empty) { |
| ui_->SetOverlayTextureEmpty(empty); |
| } |
| |
| void VrShell::ContentWebContentsDestroyed() { |
| web_contents_ = nullptr; |
| } |
| |
| void VrShell::ForceExitVr() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_forceExitVr(env, j_vr_shell_); |
| } |
| |
| void VrShell::ExitPresent() { |
| delegate_provider_->ExitWebVRPresent(); |
| } |
| |
| void VrShell::ExitFullscreen() { |
| if (GetNonNativePageWebContents() && |
| GetNonNativePageWebContents()->IsFullscreen()) { |
| GetNonNativePageWebContents()->ExitFullscreen(false); |
| } |
| } |
| |
| void VrShell::LogUnsupportedModeUserMetric(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| int mode) { |
| LogUnsupportedModeUserMetric((UiUnsupportedMode)mode); |
| } |
| |
| void VrShell::RecordVrStartAction(VrStartAction action) { |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) { |
| metrics_helper->RecordVrStartAction(action); |
| } |
| } |
| |
| void VrShell::RecordPresentationStartAction(PresentationStartAction action) { |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) |
| metrics_helper->RecordPresentationStartAction(action); |
| } |
| |
| void VrShell::ShowSoftInput(JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| bool show) { |
| ui_->ShowSoftInput(show); |
| } |
| |
| void VrShell::UpdateWebInputIndices( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| int selection_start, |
| int selection_end, |
| int composition_start, |
| int composition_end) { |
| PostToGlThread(FROM_HERE, base::BindOnce(&VrGLThread::UpdateWebInputIndices, |
| base::Unretained(gl_thread_.get()), |
| selection_start, selection_end, |
| composition_start, composition_end)); |
| } |
| |
| void VrShell::LogUnsupportedModeUserMetric(UiUnsupportedMode mode) { |
| UMA_HISTOGRAM_ENUMERATION("VR.Shell.EncounteredUnsupportedMode", mode, |
| UiUnsupportedMode::kCount); |
| } |
| |
| content::WebContents* VrShell::GetNonNativePageWebContents() const { |
| return !web_contents_is_native_page_ ? web_contents_ : nullptr; |
| } |
| |
| void VrShell::OnUnsupportedMode(UiUnsupportedMode mode) { |
| switch (mode) { |
| case UiUnsupportedMode::kUnhandledCodePoint: |
| // We should never have this case. |
| CHECK(false); |
| return; |
| case UiUnsupportedMode::kVoiceSearchNeedsRecordAudioOsPermission: { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_onUnhandledPermissionPrompt(env, j_vr_shell_); |
| return; |
| } |
| case UiUnsupportedMode::kNeedsKeyboardUpdate: { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_onNeedsKeyboardUpdate(env, j_vr_shell_); |
| return; |
| } |
| // These modes are not sent by the UI anymore. Enum values still exist to |
| // show correct exit prompt if vr-browsing-native-android-ui flag is false. |
| case UiUnsupportedMode::kUnhandledPageInfo: |
| case UiUnsupportedMode::kUnhandledCertificateInfo: |
| case UiUnsupportedMode::kUnhandledConnectionSecurityInfo: |
| case UiUnsupportedMode::kGenericUnsupportedFeature: |
| // kSearchEnginePromo should directly DOFF without showing a promo. So it |
| // should never be used from VR ui thread. |
| case UiUnsupportedMode::kSearchEnginePromo: |
| case UiUnsupportedMode::kCount: |
| NOTREACHED(); |
| return; |
| } |
| |
| NOTREACHED(); |
| } |
| |
| void VrShell::OnExitVrPromptResult(UiUnsupportedMode reason, |
| ExitVrPromptChoice choice) { |
| bool should_exit; |
| switch (choice) { |
| case ExitVrPromptChoice::CHOICE_NONE: |
| case ExitVrPromptChoice::CHOICE_STAY: |
| should_exit = false; |
| break; |
| case ExitVrPromptChoice::CHOICE_EXIT: |
| should_exit = true; |
| break; |
| } |
| |
| DCHECK_NE(reason, UiUnsupportedMode::kCount); |
| if (reason == UiUnsupportedMode::kVoiceSearchNeedsRecordAudioOsPermission) { |
| // Note that we already measure the number of times the user exits VR |
| // because of the record audio permission through |
| // VR.Shell.EncounteredUnsupportedMode histogram. This histogram measures |
| // whether the user chose to proceed to grant the OS record audio permission |
| // through the reported Boolean. |
| UMA_HISTOGRAM_BOOLEAN("VR.VoiceSearch.RecordAudioOsPermissionPromptChoice", |
| choice == ExitVrPromptChoice::CHOICE_EXIT); |
| } |
| |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_onExitVrRequestResult(env, j_vr_shell_, static_cast<int>(reason), |
| should_exit); |
| } |
| |
| void VrShell::OnContentScreenBoundsChanged(const gfx::SizeF& bounds) { |
| // We have to fit the content into the portion of the display for one eye. |
| // Thus, take only half the width. |
| int width_pixels = display_size_pixels_.width() / 2; |
| float width_meters = display_size_meters_.width() / 2; |
| |
| // The physical and pixel dimensions to draw the scene for one eye needs to be |
| // a square so that the content's aspect ratio is preserved (i.e. make pixels |
| // square for the calculations). |
| |
| // For the resolution err on the side of too many pixels so that our content |
| // is rather drawn with too high of a resolution than too low. |
| int length_pixels = std::max(width_pixels, display_size_pixels_.height()); |
| |
| // For the size err on the side of a too small area so that the font size is |
| // rather too big than too small. |
| float length_meters = std::min(width_meters, display_size_meters_.height()); |
| |
| // Calculate the virtual window size and DPR and pass this to VrShell. |
| gfx::Size window_size = gfx::ToRoundedSize( |
| gfx::ScaleSize(bounds, width_meters * kContentBoundsMetersToWindowSize)); |
| // Need to use sqrt(kContentDprFactor) to translate from a factor applicable |
| // to the area to a factor applicable to one side length. |
| float dpr = |
| (length_pixels / (length_meters * kContentBoundsMetersToWindowSize)) * |
| std::sqrt(kContentDprFactor); |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_setContentCssSize(env, j_vr_shell_, window_size.width(), |
| window_size.height(), dpr); |
| |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::ContentBoundsChanged, |
| gl_thread_->GetBrowserRenderer(), |
| window_size.width(), window_size.height())); |
| } |
| |
| void VrShell::SetVoiceSearchActive(bool active) { |
| if (!active && !speech_recognizer_) |
| return; |
| |
| if (!HasAudioPermission()) { |
| OnUnsupportedMode( |
| UiUnsupportedMode::kVoiceSearchNeedsRecordAudioOsPermission); |
| return; |
| } |
| |
| if (!speech_recognizer_) { |
| Profile* profile = ProfileManager::GetActiveUserProfile(); |
| std::string profile_locale = g_browser_process->GetApplicationLocale(); |
| speech_recognizer_.reset(new SpeechRecognizer( |
| this, ui_, |
| content::BrowserContext::GetDefaultStoragePartition(profile) |
| ->GetURLLoaderFactoryForBrowserProcessIOThread(), |
| profile->GetPrefs()->GetString(prefs::kAcceptLanguages), |
| profile_locale)); |
| } |
| if (active) { |
| speech_recognizer_->Start(); |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper) |
| metrics_helper->RecordVoiceSearchStarted(); |
| } else { |
| speech_recognizer_->Stop(); |
| } |
| } |
| |
| void VrShell::StartAutocomplete(const AutocompleteRequest& request) { |
| autocomplete_controller_->Start(request); |
| } |
| |
| void VrShell::StopAutocomplete() { |
| autocomplete_controller_->Stop(); |
| } |
| |
| void VrShell::ShowPageInfo() { |
| Java_VrShell_showPageInfo(base::android::AttachCurrentThread(), j_vr_shell_); |
| } |
| |
| bool VrShell::HasAudioPermission() { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| return Java_VrShell_hasAudioPermission(env, j_vr_shell_); |
| } |
| |
| void VrShell::PollCapturingState() { |
| poll_capturing_state_task_.Reset(base::BindRepeating( |
| &VrShell::PollCapturingState, base::Unretained(this))); |
| main_thread_task_runner_->PostDelayedTask( |
| FROM_HERE, poll_capturing_state_task_.callback(), |
| kPollCapturingStateInterval); |
| |
| scoped_refptr<MediaStreamCaptureIndicator> indicator = |
| MediaCaptureDevicesDispatcher::GetInstance() |
| ->GetMediaStreamCaptureIndicator(); |
| |
| active_capturing_.audio_capture_enabled = false; |
| active_capturing_.video_capture_enabled = false; |
| active_capturing_.screen_capture_enabled = false; |
| active_capturing_.bluetooth_connected = false; |
| background_capturing_.audio_capture_enabled = false; |
| background_capturing_.video_capture_enabled = false; |
| background_capturing_.screen_capture_enabled = false; |
| background_capturing_.bluetooth_connected = false; |
| |
| std::unique_ptr<content::RenderWidgetHostIterator> widgets( |
| content::RenderWidgetHost::GetRenderWidgetHosts()); |
| while (content::RenderWidgetHost* rwh = widgets->GetNextHost()) { |
| bool is_foreground = rwh->GetProcess()->VisibleClientCount() > 0; |
| content::RenderViewHost* rvh = content::RenderViewHost::From(rwh); |
| if (!rvh) |
| continue; |
| content::WebContents* web_contents = |
| content::WebContents::FromRenderViewHost(rvh); |
| if (!web_contents) |
| continue; |
| if (web_contents->GetRenderViewHost() != rvh) |
| continue; |
| |
| // Because a WebContents can only have one current RVH at a time, there will |
| // be no duplicate WebContents here. |
| if (indicator->IsCapturingAudio(web_contents)) { |
| if (is_foreground) |
| active_capturing_.audio_capture_enabled = true; |
| else |
| background_capturing_.audio_capture_enabled = true; |
| } |
| if (indicator->IsCapturingVideo(web_contents)) { |
| if (is_foreground) |
| active_capturing_.video_capture_enabled = true; |
| else |
| background_capturing_.video_capture_enabled = true; |
| } |
| if (indicator->IsBeingMirrored(web_contents)) { |
| if (is_foreground) |
| active_capturing_.screen_capture_enabled = true; |
| else |
| background_capturing_.screen_capture_enabled = true; |
| } |
| if (web_contents->IsConnectedToBluetoothDevice()) { |
| if (is_foreground) |
| active_capturing_.bluetooth_connected = true; |
| else |
| background_capturing_.bluetooth_connected = true; |
| } |
| } |
| |
| geolocation_config_->IsHighAccuracyLocationBeingCaptured(base::BindRepeating( |
| [](VrShell* shell, BrowserUiInterface* ui, |
| CapturingStateModel* active_capturing, |
| CapturingStateModel* background_capturing, |
| CapturingStateModel* potential_capturing, |
| bool high_accuracy_location) { |
| active_capturing->location_access_enabled = high_accuracy_location; |
| ui->SetCapturingState(*active_capturing, *background_capturing, |
| *potential_capturing); |
| }, |
| base::Unretained(this), base::Unretained(ui_), |
| base::Unretained(&active_capturing_), |
| base::Unretained(&background_capturing_), |
| base::Unretained(&potential_capturing_))); |
| } |
| |
| void VrShell::ClearFocusedElement() { |
| if (!web_contents_) |
| return; |
| |
| web_contents_->ClearFocusedElement(); |
| } |
| |
| void VrShell::ProcessContentGesture(std::unique_ptr<InputEvent> event, |
| int content_id) { |
| // Block the events if they don't belong to the current content |
| if (content_id_ != content_id) |
| return; |
| |
| if (!android_ui_gesture_target_) |
| return; |
| |
| android_ui_gesture_target_->DispatchInputEvent(std::move(event)); |
| } |
| |
| void VrShell::ProcessDialogGesture(std::unique_ptr<InputEvent> event) { |
| if (!dialog_gesture_target_) |
| return; |
| |
| dialog_gesture_target_->DispatchInputEvent(std::move(event)); |
| } |
| |
| void VrShell::UpdateGamepadData(device::GvrGamepadData pad) { |
| if (gvr_gamepad_source_active_ != pad.connected) |
| ToggleGvrGamepad(pad.connected); |
| |
| if (gvr_gamepad_data_fetcher_) |
| gvr_gamepad_data_fetcher_->SetGamepadData(pad); |
| } |
| |
| void VrShell::RegisterGvrGamepadDataFetcher( |
| device::GvrGamepadDataFetcher* fetcher) { |
| DVLOG(1) << __FUNCTION__ << "(" << fetcher << ")"; |
| gvr_gamepad_data_fetcher_ = fetcher; |
| } |
| |
| void VrShell::RegisterCardboardGamepadDataFetcher( |
| device::CardboardGamepadDataFetcher* fetcher) { |
| DVLOG(1) << __FUNCTION__ << "(" << fetcher << ")"; |
| cardboard_gamepad_data_fetcher_ = fetcher; |
| } |
| |
| bool VrShell::HasDaydreamSupport(JNIEnv* env) { |
| return Java_VrShell_hasDaydreamSupport(env, j_vr_shell_); |
| } |
| |
| content::WebContents* VrShell::GetActiveWebContents() const { |
| // TODO(tiborg): Handle the case when Tab#isShowingErrorPage returns true. |
| return web_contents_; |
| } |
| |
| bool VrShell::ShouldDisplayURL() const { |
| content::NavigationEntry* entry = GetNavigationEntry(); |
| if (!entry) { |
| return ChromeToolbarModelDelegate::ShouldDisplayURL(); |
| } |
| GURL url = entry->GetVirtualURL(); |
| // URL is of the form chrome-native://.... This is not useful for the user. |
| // Hide it. |
| if (url.SchemeIs(chrome::kChromeUINativeScheme)) { |
| return false; |
| } |
| // URL is of the form chrome://.... |
| if (url.SchemeIs(content::kChromeUIScheme)) { |
| return true; |
| } |
| return ChromeToolbarModelDelegate::ShouldDisplayURL(); |
| } |
| |
| void VrShell::OnVoiceResults(const base::string16& result) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| GURL url; |
| bool input_was_url; |
| std::tie(url, input_was_url) = |
| autocomplete_controller_->GetUrlFromVoiceInput(result); |
| |
| // TODO(http://crbug.com/817559): If the user is doing a voice search from the |
| // new tab page, no metrics data is recorded (including voice search started). |
| // Fix this. |
| |
| // This should happen before the load to avoid concurency issues. |
| SessionMetricsHelper* metrics_helper = |
| SessionMetricsHelper::FromWebContents(web_contents_); |
| if (metrics_helper && input_was_url) |
| metrics_helper->RecordUrlRequested(url, NavigationMethod::kVoiceSearch); |
| |
| Java_VrShell_loadUrl(env, j_vr_shell_, |
| base::android::ConvertUTF8ToJavaString(env, url.spec())); |
| } |
| |
| void VrShell::OnAssetsLoaded(AssetsLoadStatus status, |
| std::unique_ptr<Assets> assets, |
| const base::Version& component_version) { |
| ui_->OnAssetsLoaded(status, std::move(assets), component_version); |
| |
| if (status == AssetsLoadStatus::kSuccess) { |
| VLOG(1) << "Successfully loaded VR assets component"; |
| } else { |
| VLOG(1) << "Failed to load VR assets component"; |
| } |
| |
| AssetsLoader::GetInstance()->GetMetricsHelper()->OnAssetsLoaded( |
| status, component_version); |
| ui_finished_loading_ = true; |
| } |
| |
| void VrShell::LoadAssets() { |
| can_load_new_assets_ = false; |
| AssetsLoader::GetInstance()->Load( |
| base::BindOnce(&VrShell::OnAssetsLoaded, base::Unretained(this))); |
| } |
| |
| void VrShell::OnAssetsComponentReady() { |
| can_load_new_assets_ = true; |
| // We don't apply updates after the timer expires because that would lead to |
| // replacing the user's environment. New updates will be applied when |
| // re-entering VR. |
| if (waiting_for_assets_component_timer_.IsRunning()) { |
| waiting_for_assets_component_timer_.Stop(); |
| LoadAssets(); |
| } |
| } |
| |
| void VrShell::OnAssetsComponentWaitTimeout() { |
| ui_->OnAssetsUnavailable(); |
| ui_finished_loading_ = true; |
| } |
| |
| void VrShell::SetCookieInfo(const CookieInfoList& cookie_info_list) {} |
| |
| void VrShell::SetPermissionInfo(const PermissionInfoList& permission_info_list, |
| ChosenObjectInfoList chosen_object_info_list) { |
| // Here we'll check the current web contents for potentially in-use |
| // permissions. Accepting bluetooth is immersive mode is not currently |
| // supported, so we will not check here. Also, the ability to cast is not a |
| // page-specific potentiality, so we will not check for this, either. |
| for (const auto& info : permission_info_list) { |
| switch (info.type) { |
| case CONTENT_SETTINGS_TYPE_GEOLOCATION: |
| potential_capturing_.location_access_enabled = |
| info.setting == CONTENT_SETTING_ALLOW; |
| break; |
| case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC: |
| potential_capturing_.audio_capture_enabled = |
| info.setting == CONTENT_SETTING_ALLOW; |
| break; |
| case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA: |
| potential_capturing_.video_capture_enabled = |
| info.setting == CONTENT_SETTING_ALLOW; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| void VrShell::SetIdentityInfo(const IdentityInfo& identity_info) {} |
| |
| void VrShell::AcceptDoffPromptForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj) { |
| PostToGlThread(FROM_HERE, |
| base::BindOnce(&BrowserRenderer::AcceptDoffPromptForTesting, |
| gl_thread_->GetBrowserRenderer())); |
| } |
| |
| void VrShell::SetUiExpectingActivityForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| jint quiescence_timeout_ms) { |
| UiTestActivityExpectation ui_expectation; |
| ui_expectation.quiescence_timeout_ms = quiescence_timeout_ms; |
| PostToGlThread( |
| FROM_HERE, |
| base::BindOnce(&BrowserRenderer::SetUiExpectingActivityForTesting, |
| gl_thread_->GetBrowserRenderer(), ui_expectation)); |
| } |
| |
| void VrShell::SaveNextFrameBufferToDiskForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| jstring filepath_base) { |
| PostToGlThread( |
| FROM_HERE, |
| base::BindOnce( |
| &BrowserRenderer::SaveNextFrameBufferToDiskForTesting, |
| gl_thread_->GetBrowserRenderer(), |
| base::android::ConvertJavaStringToUTF8(env, filepath_base))); |
| } |
| |
| void VrShell::WatchElementForVisibilityChangeForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| jint element_name, |
| jint timeout_ms) { |
| VisibilityChangeExpectation visibility_expectation; |
| visibility_expectation.element_name = |
| static_cast<UserFriendlyElementName>(element_name); |
| visibility_expectation.timeout_ms = timeout_ms; |
| PostToGlThread( |
| FROM_HERE, |
| base::BindOnce( |
| &BrowserRenderer::WatchElementForVisibilityChangeForTesting, |
| gl_thread_->GetBrowserRenderer(), visibility_expectation)); |
| } |
| |
| void VrShell::ReportUiOperationResultForTesting(UiTestOperationType action_type, |
| UiTestOperationResult result) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| Java_VrShell_reportUiOperationResultForTesting(env, j_vr_shell_, |
| static_cast<int>(action_type), |
| static_cast<int>(result)); |
| } |
| |
| void VrShell::PerformControllerActionForTesting( |
| JNIEnv* env, |
| const base::android::JavaParamRef<jobject>& obj, |
| jint element_name, |
| jint action_type, |
| jfloat x, |
| jfloat y) { |
| ControllerTestInput controller_input; |
| controller_input.element_name = |
| static_cast<UserFriendlyElementName>(element_name); |
| controller_input.action = static_cast<VrControllerTestAction>(action_type); |
| controller_input.position = gfx::PointF(x, y); |
| PostToGlThread( |
| FROM_HERE, |
| base::BindOnce(&BrowserRenderer::PerformControllerActionForTesting, |
| gl_thread_->GetBrowserRenderer(), controller_input)); |
| } |
| |
| std::unique_ptr<PageInfo> VrShell::CreatePageInfo() { |
| if (!web_contents_) |
| return nullptr; |
| |
| content::NavigationEntry* entry = |
| web_contents_->GetController().GetVisibleEntry(); |
| if (!entry) |
| return nullptr; |
| |
| SecurityStateTabHelper* helper = |
| SecurityStateTabHelper::FromWebContents(web_contents_); |
| security_state::SecurityInfo security_info; |
| helper->GetSecurityInfo(&security_info); |
| |
| return std::make_unique<PageInfo>( |
| this, Profile::FromBrowserContext(web_contents_->GetBrowserContext()), |
| TabSpecificContentSettings::FromWebContents(web_contents_), web_contents_, |
| entry->GetVirtualURL(), security_info); |
| } |
| |
| gfx::AcceleratedWidget VrShell::GetRenderSurface() { |
| return surface_window_; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Native JNI methods |
| // ---------------------------------------------------------------------------- |
| |
| jlong JNI_VrShell_Init(JNIEnv* env, |
| const JavaParamRef<jobject>& obj, |
| const JavaParamRef<jobject>& delegate, |
| jboolean for_web_vr, |
| jboolean browsing_disabled, |
| jboolean has_or_can_request_audio_permission, |
| jlong gvr_api, |
| jboolean reprojected_rendering, |
| jfloat display_width_meters, |
| jfloat display_height_meters, |
| jint display_width_pixels, |
| jint display_pixel_height, |
| jboolean pause_content, |
| jboolean low_density, |
| jboolean is_standalone_vr_device) { |
| UiInitialState ui_initial_state; |
| ui_initial_state.browsing_disabled = browsing_disabled; |
| ui_initial_state.in_web_vr = for_web_vr; |
| ui_initial_state.has_or_can_request_audio_permission = |
| has_or_can_request_audio_permission; |
| ui_initial_state.assets_supported = AssetsLoader::AssetsSupported(); |
| ui_initial_state.is_standalone_vr_device = is_standalone_vr_device; |
| ui_initial_state.create_tabs_view = |
| base::FeatureList::IsEnabled(chrome::android::kVrBrowsingTabsView); |
| ui_initial_state.use_new_incognito_strings = |
| base::FeatureList::IsEnabled(features::kIncognitoStrings); |
| |
| return reinterpret_cast<intptr_t>(new VrShell( |
| env, obj, ui_initial_state, |
| VrShellDelegate::GetNativeVrShellDelegate(env, delegate), |
| reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering, |
| display_width_meters, display_height_meters, display_width_pixels, |
| display_pixel_height, pause_content, low_density)); |
| } |
| |
| } // namespace vr |
