Hide fullscreen rotation jank

content/browser/renderer_host/fullscreen_jank_detector.cc

+// Copyright (c) 2017 The Chromium Authors. All rights reserved.

[boliu, 2017/07/05 17:39:48]

no (c)

+// 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/fullscreen_jank_detector.h"
+
+#include "base/logging.h"
+
+namespace content {
+
+void FullscreenJankDetector::OnFullscreenStateChanged(bool is_fullscreen) {
+  web_contents_is_fullscreen_ = is_fullscreen;
+  UpdateFullscreenState();
+}
+
+void FullscreenJankDetector::OnPhysicalBackingSizeChanged(gfx::Size size) {
+  view_size_ = size;
+  UpdateFullscreenState();
+}
+
+void FullscreenJankDetector::OnFrameMetadataUpdated(bool frame_is_fullscreen,
+                                                    gfx::Size frame_size) {
+  frame_is_fullscreen_ = frame_is_fullscreen;
+  frame_size_ = frame_size;

[boliu, 2017/07/05 17:39:48]

this frame size may not be the "final" size, even if frame_is_fullscreen is in
its final state.

that's because browser side acks the fullscreen request *before* the actual
resize has happened (ie backing size changed here). So:
* renderer request fullscreen
* browser receives request, sends ack to renderer, and at the same time, request
fullscreen
then these two things races:
a) renderer receives ack, and pushes a frame fullscreen set, but potentially
wrong size
b) actual resize happens

if a) happens first, then you can still get an unwanted bad frame in here

I am aware that right now you have code in blink to wait for the resize before
setting fullscreen, so this can't actually happen. But I don't think that's
acceptable blink code, since there is definitely code that specifically handles
fullscreen that does *not* involve a resize.

+  UpdateFullscreenState();
+}
+
+void FullscreenJankDetector::UpdateFullscreenState() {
+  bool mismatched_fullscreen_states =
+      web_contents_is_fullscreen_ != frame_is_fullscreen_;
+  bool mismatched_sizes = view_size_ != frame_size_;
+
+  switch (state_) {
+    // From kNotFullscreen, we transition to kEnteringFullscreen whenever the
+    // fullscreen state changes.
+    case FullscreenState::kNotFullscreen:
+      if (mismatched_fullscreen_states) {
+        DCHECK(web_contents_is_fullscreen_);
+        state_ = FullscreenState::kEnteringFullscreen;
+      }
+      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_);
+        state_ = FullscreenState::kExitingFullscreen;
+      } else if (mismatched_sizes) {
+        state_ = FullscreenState::kFullscreenRotation;
+      }
+      break;
+    // From any transition state, once we receive a "good" frame we transition
+    // to the proper "good" state.
+    case FullscreenState::kExitingFullscreen:

[boliu, 2017/07/05 17:39:48]

looks like these three states can just be merged?

+    case FullscreenState::kEnteringFullscreen:
+    case FullscreenState::kFullscreenRotation:
+      if (!mismatched_fullscreen_states && !mismatched_sizes) {
+        state_ = web_contents_is_fullscreen_ ? FullscreenState::kFullscreen
+                                             : FullscreenState::kNotFullscreen;
+      }
+      break;
+  }
+}
+
+bool FullscreenJankDetector::IsInFullscreenTransition() const {
+  return (state_ == FullscreenState::kEnteringFullscreen ||
+          state_ == FullscreenState::kExitingFullscreen ||
+          state_ == FullscreenState::kFullscreenRotation);
+}
+
+}  // namespace content