Hide fullscreen rotation jank

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 11 matching lines @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/latency_info_swap_promise.h"
+#include "cc/quads/solid_color_draw_quad.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "components/viz/display_compositor/gl_helper.h"
 #include "content/browser/accessibility/browser_accessibility_manager_android.h"
 #include "content/browser/android/composited_touch_handle_drawable.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/ime_adapter_android.h"
@@ skipping 510 matching lines @@
     RenderWidgetHostView* reference_host_view) {
   NOTIMPLEMENTED();
 }
 
 RenderWidgetHost*
 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAndroid::WasResized() {
+  // If we're entering a fullscreen transition, show black until the transition
+  // is completed.
+  if (content_view_core_ &&
+      view_.GetPhysicalBackingSize() != prev_physical_backing_size_) {
+    bool is_fullscreen = content_view_core_->GetWebContents()->IsFullscreen();
+    if (is_fullscreen || was_fullscreen_) {
+      fullscreen_transitioning_ = true;
+
+      // Immediately queue a black frame to hide jank while we wait to receive a
+      // "good" frame via SubmitCompositorFrame.
+      cc::CompositorFrame frame;
+      frame.render_pass_list.push_back(CreateBlackRenderPass());
+      frame.metadata.root_background_color = SK_ColorBLACK;
+      delegated_frame_host_->ForceFrame(std::move(frame));
+      UpdateBackgroundColor(SK_ColorBLACK);
+    }
+    was_fullscreen_ = is_fullscreen;
+    prev_physical_backing_size_ = view_.GetPhysicalBackingSize();

[Khushal, 2017/05/24 05:14:22]

I'm a bit confused about saving the previous fullscreen and size state here. We
just want to make sure that for fullscreen transitions, the physical backing
size matches the frame size right? Would it be sufficient to do:

bool IsInFullscreenTransition() const {
   if (content_view_core_->IsFullscreen() || current_frame_is_fullscreen_) {
      return (content_view_core_->IsFullscreen() !=
current_frame_is_fullscreen_)
                || (view_.GetPhysicalBackingSize() != current_surface_size_);
  }
}

The current_frame stuff stored based on the CompositorFrameMetadata from the
last frame.

// If either the browser or renderer's frame is in fullscreen state, fallback to
a black frame when sizes mismatch.

}

[steimel, 2017/05/24 19:32:58]

Hmm I may be able to simplify some of the logic, but the issue with this is that
it doesn't take into account the top_controls stuff, and we'll need a bool that
keeps track of whether or not we're still in a fullscreen transition since
coming out of one we'll hit a point where both
content_view_core_->IsFullscreen() and current_frame_is_fullscreen_ are false,
but we're still blocking frames for other reasons. But we'll only want to check
those reasons when we're mid-transition if that makes sense. We can discuss this
more offline. I'm also planning to cover this logic on the document I'm working
on

+  }
   host_->WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
   // Ignore the given size as only the Java code has the power to
   // resize the view on Android.
   default_bounds_ = gfx::Rect(default_bounds_.origin(), size);
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
@@ skipping 602 matching lines @@
                                     bad_message::RWH_BAD_FRAME_SINK_REQUEST);
     return;
   }
   delegated_frame_host_->CompositorFrameSinkChanged();
   renderer_compositor_frame_sink_ = renderer_compositor_frame_sink;
   // Accumulated resources belong to the old RendererCompositorFrameSink and
   // should not be returned.
   surface_returned_resources_.clear();
 }
 
+std::unique_ptr<cc::RenderPass>
+RenderWidgetHostViewAndroid::CreateBlackRenderPass() {
+  gfx::Rect rect(current_surface_size_);
+  std::unique_ptr<cc::RenderPass> rp = cc::RenderPass::Create();
+  rp->SetNew(1, rect, gfx::Rect(), gfx::Transform());
+  rp->has_transparent_background = false;
+  cc::SharedQuadState* sqs = rp->CreateAndAppendSharedQuadState();
+  sqs->SetAll(gfx::Transform(), rect, rect, rect, false, 1.0,
+              SkBlendMode::kColor, 1);
+  cc::SolidColorDrawQuad* quad =
+      rp->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
+  quad->SetNew(sqs, rect, rect, SK_ColorBLACK, false);
+  return rp;
+}
+
+bool RenderWidgetHostViewAndroid::CheckForFullscreenTransitionJank(
+    const cc::CompositorFrameMetadata& metadata) {
+  // Sometimes we'll receive a new frame before WasResized initializes a
+  // fullscreen transition. In that case, we'll block everything until
+  // WasResized is called.
+  if (content_view_core_ &&
+      content_view_core_->GetWebContents()->IsFullscreen() != was_fullscreen_) {
+    return true;
+  }
+
+  // We only check for fullscreen jank during a fullscreen transition.
+  if (fullscreen_transitioning_) {
+    bool top_controls_transitioning = metadata.top_controls_shown_ratio > 0 &&
+                                      metadata.top_controls_shown_ratio < 1;
+    bool bottom_controls_transitioning =
+        metadata.bottom_controls_shown_ratio > 0 &&
+        metadata.bottom_controls_shown_ratio < 1;
+    bool mismatched_fullscreen_states =
+        content_view_core_ &&
+        (content_view_core_->GetWebContents()->IsFullscreen() !=
+         metadata.is_fullscreen);
+    bool mismatched_layer_sizes =
+        view_.GetPhysicalBackingSize() != metadata.device_viewport_size;

[Khushal, 2017/05/24 05:14:23]

Shouldn't we be comparing this with the |current_surface_size_|?

[steimel, 2017/05/24 19:32:58]

Well, view_.GetPhysicalBackingSize is the "correct" physical size we're looking
for, and metadata.device_viewport_size is the physical size of the incoming
frame. current_surface_size_ is the size of the last good frame we received.
Unless you mean that I would compare what the new frame *would* set
current_surface_size_ to with view_.GetPhysicalBackingSize, which could
potentially work but I haven't checked it out.

[Khushal, 2017/05/25 03:33:40]

Yup, my bad for not stating that clearly. But you should compare it to the size
of the root render pass, which is the size of the incoming frame.

[steimel, 2017/06/06 03:07:53]

Done.

+
+    gfx::Size modified_scrollable_viewport_size =
+        gfx::ToFlooredSize(gfx::ScaleSize(metadata.scrollable_viewport_size,
+                                          metadata.page_scale_factor));
+    bool controls_will_transition =

[Khushal, 2017/05/24 05:14:23]

Could you describe what the behaviour is for top controls during the transition?
I think we go into this persistent fullscreen state that hides the toolbar
android view in fullscreen. But I'm not totally clear on how that affects the
composited toolbar. And what happens in the out of fullscreen transition.

[steimel, 2017/05/24 19:32:58]

So this particular check is something that's used when exiting fullscreen. There
is jank that happens as the top controls expands from shown_ratio == 0 to
shown_ratio == 1. This is normally hidden via the top_controls_transitioning
condition above. However, there are times where the exiting fullscreen
transition gets to a "good" state before the top controls begin their expansion.
This means that the fullscreen_transition will be marked done and we'll be
showing frames and therefore miss the chance to hide that jank. I don't have a
full understanding of the details, but content_view_core_->GetViewSize seems to
be aware that it's about to lose the height space from the controls before they
start coming down which is why this check is true when the controls are coming
down but haven't started yet. I did just realize that for completeness I should
probably check that shown_ratio == 0 and that DoBrowserControlsShrinkBlinkSize()
== true (I should also check that bool for the transitioning conditions).

+        content_view_core_ && (content_view_core_->GetViewSize().width() ==
+                                   modified_scrollable_viewport_size.width() &&
+                               content_view_core_->GetViewSize().height() !=
+                                   modified_scrollable_viewport_size.height());
+
+    if (top_controls_transitioning || bottom_controls_transitioning ||
+        mismatched_fullscreen_states || mismatched_layer_sizes ||
+        controls_will_transition) {
+      return true;
+    } else {
+      // Done with current fullscreen transition.
+      fullscreen_transitioning_ = false;
+    }
+  }
+
+  return false;
+}
+
 void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
     const cc::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame) {
   if (!delegated_frame_host_) {
     DCHECK(!using_browser_compositor_);
     return;
   }
 
+  if (CheckForFullscreenTransitionJank(frame.metadata)) {
+    // Block this frame since it will look janky.
+    frame.render_pass_list.clear();
+    frame.render_pass_list.push_back(CreateBlackRenderPass());
+    frame.metadata.root_background_color = SK_ColorBLACK;
+    UpdateBackgroundColor(SK_ColorBLACK);
+  }
+
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
   DCHECK(!frame.render_pass_list.empty());
 
   cc::RenderPass* root_pass = frame.render_pass_list.back().get();
   current_surface_size_ = root_pass->output_rect.size();
   bool is_transparent = root_pass->has_transparent_background;
 
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
   bool has_content = !current_surface_size_.IsEmpty();
@@ skipping 1036 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content