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 547 matching lines @@
 
 RenderWidgetHost*
 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAndroid::WasResized() {
   host_->WasResized();
 }
 
+void RenderWidgetHostViewAndroid::OnFullscreenStateChanged(
+    bool entered_fullscreen) {
+  web_contents_is_fullscreen_ = entered_fullscreen;
+  EvictFrameIfNecessary(false);

[Khushal, 2017/06/14 19:43:14]

nit: UpdateFullscreenState?

[steimel, 2017/06/14 21:46:16]

Done.

+}
+
 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) {
   default_bounds_ = rect;
 }
 
@@ skipping 599 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();
 }
 
+void RenderWidgetHostViewAndroid::EvictFrameIfNecessary(
+    bool physical_backing_resized) {
+  bool mismatched_fullscreen_states =
+      web_contents_is_fullscreen_ != current_frame_is_fullscreen_;
+  bool mismatched_sizes =
+      view_.GetPhysicalBackingSize() != current_surface_size_;
+
+  if (physical_backing_resized) {

[liberato (no reviews please), 2017/06/14 21:01:50]

nit: no need for {}

[steimel, 2017/06/14 21:46:16]

Done.

+    awaiting_resize_ = false;
+  }
+
+  switch (fullscreen_state_) {
+    // From kNotFullscreen, we transition to kEnteringFullscreen whenever the
+    // fullscreen state changes.
+    case FullscreenState::kNotFullscreen:
+      if (mismatched_fullscreen_states) {

[Khushal, 2017/06/14 19:43:14]

Should this be a DCHECK that web_contents_is_fullscreen_? Because the renderer
doesn't transition until the browser Acks the request.

[steimel, 2017/06/14 21:46:16]

Done.

+        fullscreen_state_ = FullscreenState::kEnteringFullscreen;
+        awaiting_resize_ = !physical_backing_resized;

[Khushal, 2017/06/14 19:43:14]

This should also be a DCHECK I think. You should definitely see a resize *after*
the transition is requested.

[steimel, 2017/06/14 21:46:16]

Done.

+      }
+      break;
+    // From kFullscreen, we transition to kExitingFullscreen on a fullscreen
+    // state change, or to kFullscreenRotation if we get a new size.
+    case FullscreenState::kFullscreen:
+      if (mismatched_fullscreen_states) {

[Khushal, 2017/06/14 19:43:14]

Same DCHECKs here but flipped. Browser transitions out of fullscreen first and
you should see a resize for sure.

[steimel, 2017/06/14 21:46:16]

Done.

+        fullscreen_state_ = FullscreenState::kExitingFullscreen;
+        awaiting_resize_ = !physical_backing_resized;
+      }
+      if (mismatched_sizes) {
+        // TODO(steimel): Do we want to restrict this transition to when the
+        // width/height have swapped (indicating a proper rotation), or are we
+        // fine with any size change being treated as a rotation?
+        fullscreen_state_ = FullscreenState::kFullscreenRotation;

[Khushal, 2017/06/14 19:43:14]

The only reason we needed the extra state was to use in CanShowThumbnail right?
I'd prefer just evicting the frame on any size mismatch while in fullscreen and
not showing the thumbnail at all in fullscreen state. But this is good too.

[steimel, 2017/06/14 21:46:16]

Acknowledged.

+      }
+      break;
+    // From any transition state, once we receive a "good" frame we transition
+    // to the proper "good" state.
+    case FullscreenState::kExitingFullscreen:
+    case FullscreenState::kEnteringFullscreen:
+    case FullscreenState::kFullscreenRotation:
+      if (!mismatched_fullscreen_states && !mismatched_sizes &&
+          !awaiting_resize_) {
+        fullscreen_state_ = web_contents_is_fullscreen_
+                                ? FullscreenState::kFullscreen
+                                : FullscreenState::kNotFullscreen;
+      }
+      break;
+  }
+
+  if (fullscreen_state_ == FullscreenState::kEnteringFullscreen ||
+      fullscreen_state_ == FullscreenState::kExitingFullscreen ||
+      fullscreen_state_ == FullscreenState::kFullscreenRotation) {
+    EvictDelegatedFrame();
+    UpdateBackgroundColor(SK_ColorBLACK);
+  }
+}
+
 void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
     const cc::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame) {
   if (!delegated_frame_host_) {
     DCHECK(!using_browser_compositor_);
     return;
   }
 
   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();
+  current_frame_is_fullscreen_ = frame.metadata.is_fullscreen;
   bool is_transparent = root_pass->has_transparent_background;
 
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
   bool has_content = !current_surface_size_.IsEmpty();
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
                  weak_ptr_factory_.GetWeakPtr(), true /* is_swap_ack */);
 
@@ skipping 11 matching lines @@
     frame_evictor_->SwappedFrame(!host_->is_hidden());
     AcknowledgeBeginFrame(ack);
   }
 
   if (host_->is_hidden())
     RunAckCallbacks();
 
   // As the metadata update may trigger view invalidation, always call it after
   // any potential compositor scheduling.
   OnFrameMetadataUpdated(std::move(metadata), is_transparent);
+
+  EvictFrameIfNecessary(false);
 }
 
 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
   DCHECK(!delegated_frame_host_ ||
          delegated_frame_host_->HasDelegatedContent() ==
              frame_evictor_->HasFrame());
 
   if (!delegated_frame_host_)
     return;
 
   if (!delegated_frame_host_->HasDelegatedContent())
     return;
 
   frame_evictor_->DiscardedFrame();
   delegated_frame_host_->DestroyDelegatedContent();
+  current_surface_size_.SetSize(0, 0);
 }
 
 void RenderWidgetHostViewAndroid::OnDidNotProduceFrame(
     const cc::BeginFrameAck& ack) {
   if (!delegated_frame_host_) {
     // We are not using the browser compositor and there's no DisplayScheduler
     // that needs to be notified about the BeginFrameAck, so we can drop it.
     DCHECK(!using_browser_compositor_);
     return;
   }
@@ skipping 796 matching lines @@
   // unintended shift+click interpretation of all accessibility clicks.
   // See crbug.com/443247.
   if (web_gesture.GetType() == blink::WebInputEvent::kGestureTap &&
       web_gesture.GetModifiers() == blink::WebInputEvent::kShiftKey) {
     web_gesture.SetModifiers(blink::WebInputEvent::kNoModifiers);
   }
   SendGestureEvent(web_gesture);
 }
 
 void RenderWidgetHostViewAndroid::OnPhysicalBackingSizeChanged() {
+  // If we're entering a fullscreen transition, show black until the transition
+  // is completed.
+  EvictFrameIfNecessary(true);
   WasResized();
 }
 
 void RenderWidgetHostViewAndroid::OnContentViewCoreDestroyed() {
   SetContentViewCore(NULL);
   overscroll_controller_.reset();
 }
 
 void RenderWidgetHostViewAndroid::OnRootWindowVisibilityChanged(bool visible) {
   TRACE_EVENT1("browser",
@@ skipping 208 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content