Disable Android virtual keyboard when in VR shell

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
@@ skipping 425 matching lines @@
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       begin_frame_source_(nullptr),
       outstanding_begin_frame_requests_(0),
       is_showing_(!widget_host->is_hidden()),
       is_window_visible_(true),
       is_window_activity_started_(true),
-      is_showing_overscroll_glow_(true),
+      is_in_vr_(false),
       content_view_core_(nullptr),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_compositor_frame_sink_id_(kUndefinedCompositorFrameSinkId),
       gesture_provider_(ui::GetGestureProviderConfig(
                             ui::GestureProviderConfigType::CURRENT_PLATFORM),
                         this),
       stylus_text_selector_(this),
       using_browser_compositor_(CompositorImpl::IsInitialized()),
       synchronous_compositor_client_(nullptr),
@@ skipping 312 matching lines @@
     RenderWidgetHostViewBase* updated_view,
     bool did_change_state) {
   DCHECK_EQ(text_input_manager_, text_input_manager);
   // If there are no active widgets, the TextInputState.type should be reported
   // as none.
   const TextInputState& state =
       GetTextInputManager()->GetActiveWidget()
           ? *GetTextInputManager()->GetTextInputState()
           : TextInputState();
 
-  if (!content_view_core_)
+  if (!content_view_core_ || is_in_vr_)

[EhsanK, 2017/01/13 21:55:24]

I was wondering if the intention of the CL was to avoid notifying
ContentViewCore altogether, which I guess does more than just not showing the
VK?

If yes, shouldn't we be updating the renderer process(es) on the page to to stop
sending updates (say in RenderWidget::UpdateTextInputState() we just early
return is |is_in_vr_| is true)? WDYT?

If the goal here is just to stop VK from popping up, then wouldn't modifying the
state so that TextInputState.show_ime_if_needed == false do the trick? This
could also happen in RenderWidget::UpdateTextInputState(). In that case this
method should be not be changed I believe.

[asimjour, 2017/01/16 19:28:41]

This is a temporary solution. For now I want to stop all the popups (keyboard,
text selection, paste popup, ...), after that I should add VR support for all
these popups one by one, and remove the disabling from here.
we can have three different temporary solutions
1- return when it's needed (the current solution)
2- send an IPC to set VR mode in RendererWidget or RendererView.
3- update the consumer of the events so that they don't show anything.
Based on our offline discussion and since this is a temporary solution, I would
rather to stick to the first solution.

[EhsanK, 2017/01/16 20:23:11]

sgtm. The benefit of doing (2) is not sending unused IPC on Android. But since
this situation is temporary, it might not be worth doing because it will be some
code which will be removed soon. Also there seems to be a bit more to sending
the IPC since Selection updates come from RenderFrame and TextInputState from
RenderWidget. Also, you would have to send a "Page" message through
WebContentsImpl and on the renderer side, handle it in RenderViewImpl to notify
all local root RenderFrameImpls and RenderWidgets in that process.

     return;
 
   content_view_core_->UpdateImeAdapter(

[EhsanK, 2017/01/13 21:55:24]

Regarding the second point above: Here I think the UpdateImeAdapter is doing
more than ImeAdapter. The users of this seem to be ImeAdapter,
JoystickScrollProvider, Tab.java for full screen. I am not sure if any of these
are being used in VR mode.

[asimjour, 2017/01/16 19:28:41]

The UpdateImeAdapter is doing more, but other changes are consequence of showing
the keyboard. So, it is safe to stop them all from here.

[EhsanK, 2017/01/16 20:23:11]

Acknowledged.

       GetNativeImeAdapter(), static_cast<int>(state.type), state.flags,
       state.mode, state.value, state.selection_start, state.selection_end,
       state.composition_start, state.composition_end, state.show_ime_if_needed,
       state.is_non_ime_change);
 }
 
 void RenderWidgetHostViewAndroid::UpdateBackgroundColor(SkColor color) {
   if (cached_background_color_ == color)
     return;
 
@@ skipping 150 matching lines @@
   delete this;
 }
 
 void RenderWidgetHostViewAndroid::SetTooltipText(
     const base::string16& tooltip_text) {
   // Tooltips don't makes sense on Android.
 }
 
 void RenderWidgetHostViewAndroid::SelectionChanged(const base::string16& text,
                                                    size_t offset,
                                                    const gfx::Range& range) {

[EhsanK, 2017/01/13 21:55:23]

Similar to the OnUpdateTextInputStateCalled() above:
The call to base class's SelectionChange will update |selection_text_offset_|,
|selection_range_|, and |selection_text_|. However, AFAIK we never use those
values on Android and in fact, it seems like we should at some point get rid of
the call to the base class code (that is a separate problem of course). Sicne we
do not update the |content_view_core_| at all, then maybe we should not receive
updates to begin with? WDYT?

   RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 
-  if (!content_view_core_)
+  if (!content_view_core_ || is_in_vr_)
     return;
   if (range.is_empty()) {
     content_view_core_->OnSelectionChanged("");
     return;
   }
 
   DCHECK(!text.empty());
   size_t pos = range.GetMin() - offset;
   size_t n = range.length();
 
   DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
   if (pos >= text.length()) {
     NOTREACHED() << "The text can not cover range.";
     return;
   }
 
   std::string utf8_selection = base::UTF16ToUTF8(text.substr(pos, n));
 
   content_view_core_->OnSelectionChanged(utf8_selection);

[EhsanK, 2017/01/13 21:55:23]

I am not familiar with Java side, but, looking at the code it seems like the
call here would notify the SelectionPopup and eventually the
ContextualSearchClient. Is this part of the change in this CL not to show the
popup in VR mode? In that case maybe the CL description could take note of it
(just a suggestion).

[asimjour, 2017/01/16 19:28:40]

the CL description is updated.

[EhsanK, 2017/01/16 20:23:11]

Acknowledged.

 }
 
 void RenderWidgetHostViewAndroid::SetBackgroundColor(SkColor color) {
   RenderWidgetHostViewBase::SetBackgroundColor(color);
   host_->SetBackgroundOpaque(GetBackgroundOpaque());
   UpdateBackgroundColor(color);
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
@@ skipping 546 matching lines @@
   // switches to Surfaces and the Browser's commit isn't in the critical path.
   args.deadline = sync_compositor_ ? base::TimeTicks()
   : args.frame_time + (args.interval * 0.6);
   host_->Send(new ViewMsg_BeginFrame(host_->GetRoutingID(), args));
   if (sync_compositor_)
     sync_compositor_->DidSendBeginFrame(view_.GetWindowAndroid());
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
   bool needs_animate = false;
-  if (overscroll_controller_ && is_showing_overscroll_glow_) {
+  if (overscroll_controller_ && !is_in_vr_) {
     needs_animate |= overscroll_controller_->Animate(
         frame_time, content_view_core_->GetViewAndroid()->GetLayer());
   }
   if (selection_controller_)
     needs_animate |= selection_controller_->Animate(frame_time);
   return needs_animate;
 }
 
 void RenderWidgetHostViewAndroid::RequestDisallowInterceptTouchEvent() {
   if (content_view_core_)
@@ skipping 194 matching lines @@
 
 void RenderWidgetHostViewAndroid::SetTextHandlesTemporarilyHidden(bool hidden) {
   if (selection_controller_)
     selection_controller_->SetTemporarilyHidden(hidden);
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
-void RenderWidgetHostViewAndroid::SetShowingOverscrollGlow(bool showing_glow) {
-  is_showing_overscroll_glow_ = showing_glow;
+void RenderWidgetHostViewAndroid::SetIsInVR(bool is_in_vr) {
+  is_in_vr_ = is_in_vr;
 }
 
 void RenderWidgetHostViewAndroid::DidOverscroll(
     const ui::DidOverscrollParams& params) {
   if (sync_compositor_)
     sync_compositor_->DidOverscroll(params);
 
   if (!content_view_core_ || !is_showing_)
     return;
 
@@ skipping 303 matching lines @@
   if (!window_android)
     return;
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor,
       ui::GetScaleFactorForNativeView(GetNativeView()));
-  is_showing_overscroll_glow_ = true;
 }
 
 }  // namespace content