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 53 matching lines @@
 #include "content/common/gpu_stream_constants.h"
 #include "content/common/input_messages.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/android/compositor.h"
 #include "content/public/browser/android/synchronous_compositor_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
+#include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_message_start.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkCanvas.h"
@@ skipping 474 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;
+  UpdateFullscreenState(false);
+}
+
 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::UpdateFullscreenState(
+    bool physical_backing_resized) {
+  if (!base::FeatureList::IsEnabled(features::kHideFullscreenTransitionJank))
+    return;
+
+  bool mismatched_fullscreen_states =
+      web_contents_is_fullscreen_ != current_frame_is_fullscreen_;
+  bool mismatched_sizes =
+      view_.GetPhysicalBackingSize() != current_surface_size_;
+
+  if (physical_backing_resized)
+    fullscreen_transition_awaiting_resize_ = false;

[Khushal, 2017/06/15 23:44:50]

I'm still a bit unsure about whether this is the best way to do this.
Essentially we want to know whether the Surface for the compositor has been
resized to what it should be based on the current fullscreen state. May be a
better alternate would be to have an API using ViewAndroidDelegate that queries
for exactly that. I'll let content/chrome folks suggest on that.

Also, Bo can verify whether this this will work with WebView.

+
+  switch (fullscreen_state_) {
+    // From kNotFullscreen, we transition to kEnteringFullscreen whenever the
+    // fullscreen state changes.
+    case FullscreenState::kNotFullscreen:
+      if (mismatched_fullscreen_states) {
+        DCHECK(web_contents_is_fullscreen_);
+        DCHECK(!physical_backing_resized);
+        fullscreen_state_ = FullscreenState::kEnteringFullscreen;
+        fullscreen_transition_awaiting_resize_ = true;
+      }
+      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) {
+        DCHECK(!web_contents_is_fullscreen_);
+        DCHECK(!physical_backing_resized);
+        fullscreen_state_ = FullscreenState::kExitingFullscreen;
+        fullscreen_transition_awaiting_resize_ = true;
+      }
+      if (mismatched_sizes)
+        fullscreen_state_ = FullscreenState::kFullscreenRotation;
+      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 &&
+          !fullscreen_transition_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);
+
+  UpdateFullscreenState(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 667 matching lines @@
 
 void RenderWidgetHostViewAndroid::SetTextHandlesTemporarilyHidden(bool hidden) {
   if (touch_selection_controller_)
     touch_selection_controller_->SetTemporarilyHidden(hidden);
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
+bool RenderWidgetHostViewAndroid::CanShowThumbnailPlaceholder() const {
+  return !(fullscreen_state_ == FullscreenState::kEnteringFullscreen ||
+           fullscreen_state_ == FullscreenState::kExitingFullscreen ||
+           fullscreen_state_ == FullscreenState::kFullscreenRotation);
+}
+
 void RenderWidgetHostViewAndroid::SetIsInVR(bool is_in_vr) {
   is_in_vr_ = is_in_vr;
 }
 
 bool RenderWidgetHostViewAndroid::IsInVR() const {
   return is_in_vr_;
 }
 
 void RenderWidgetHostViewAndroid::DidOverscroll(
     const ui::DidOverscrollParams& params) {
@@ skipping 109 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.
+  UpdateFullscreenState(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