Renaming gpu swap buffer callbacks and the screenshot latency component.

content/browser/renderer_host/render_widget_host_impl.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_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 1436 matching lines @@
   }
 }
 
 void RenderWidgetHostImpl::GetSnapshotFromBrowser(
     const GetSnapshotFromBrowserCallback& callback,
     bool from_surface) {
   int id = next_browser_snapshot_id_++;
   if (from_surface) {
     pending_surface_browser_snapshots_.insert(std::make_pair(id, callback));
     ui::LatencyInfo latency_info;
-    latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT, 0,
-                                  id);
+    latency_info.AddLatencyNumber(ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT,
+                                  0, id);
     Send(new ViewMsg_ForceRedraw(GetRoutingID(), latency_info));
     return;
   }
 
 #if defined(OS_MACOSX)
   // MacOS version of underlying GrabViewSnapshot() blocks while
   // display/GPU are in a power-saving mode, so make sure display
   // does not go to sleep for the duration of reading a snapshot.
   if (pending_browser_snapshots_.empty()) {
     DCHECK(!power_save_blocker_);
     power_save_blocker_.reset(new device::PowerSaveBlocker(
         device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
         device::PowerSaveBlocker::kReasonOther, "GetSnapshot",
         BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
   }
 #endif
   pending_browser_snapshots_.insert(std::make_pair(id, callback));
   ui::LatencyInfo latency_info;
-  latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT, 0,
+  latency_info.AddLatencyNumber(ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT, 0,
                                 id);
   Send(new ViewMsg_ForceRedraw(GetRoutingID(), latency_info));
 }
 
 const NativeWebKeyboardEvent*
     RenderWidgetHostImpl::GetLastKeyboardEvent() const {
   return input_router_->GetLastKeyboardEvent();
 }
 
 void RenderWidgetHostImpl::SelectionChanged(const base::string16& text,
@@ skipping 262 matching lines @@
       delegate_->RendererResponsive(this);
   }
 }
 
 void RenderWidgetHostImpl::ClearDisplayedGraphics() {
   NotifyNewContentRenderingTimeoutForTesting();
   if (view_)
     view_->ClearCompositorFrame();
 }
 
+void RenderWidgetHostImpl::OnGpuSwapBufersCompletedInternal(
+    const ui::LatencyInfo& latency_info) {
+  ui::LatencyInfo::LatencyComponent window_snapshot_component;
+  if (latency_info.FindLatency(ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT,
+                               GetLatencyComponentId(),
+                               &window_snapshot_component)) {
+    int sequence_number =
+        static_cast<int>(window_snapshot_component.sequence_number);
+#if defined(OS_MACOSX)
+    // On Mac, when using CoreAnmation, there is a delay between when content

[tdresser, 2017/04/03 15:57:11]

CoreAnmation -> CoreAnimation

[mfomitchev, 2017/04/03 17:31:00]

Done.

+    // is drawn to the screen, and when the snapshot will actually pick up
+    // that content. Insert a manual delay of 1/6th of a second (to simulate
+    // 10 frames at 60 fps) before actually taking the snapshot.
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&RenderWidgetHostImpl::WindowSnapshotReachedScreen,
+                   weak_factory_.GetWeakPtr(), sequence_number),
+        base::TimeDelta::FromSecondsD(1. / 6));
+#else
+    WindowSnapshotReachedScreen(sequence_number);
+#endif
+  }
+
+  latency_tracker_.OnGpuSwapBufersCompleted(latency_info);
+}
+
 void RenderWidgetHostImpl::OnRenderProcessGone(int status, int exit_code) {
   // RenderFrameHost owns a RenderWidgetHost when it needs one, in which case
   // it handles destruction.
   if (!owned_by_render_frame_host_) {
     // TODO(evanm): This synchronously ends up calling "delete this".
     // Is that really what we want in response to this message?  I'm matching
     // previous behavior of the code here.
     Destroy(true);
   } else {
     RendererExited(static_cast<base::TerminationStatus>(status), exit_code);
@@ skipping 562 matching lines @@
 
   if (delegate_)
     delegate_->ResizeDueToAutoResize(this, new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
   latency_tracker_.SetDelegate(nullptr);
 }
 
-void RenderWidgetHostImpl::FrameSwapped(const ui::LatencyInfo& latency_info) {
-  ui::LatencyInfo::LatencyComponent window_snapshot_component;
-  if (latency_info.FindLatency(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
-                               GetLatencyComponentId(),
-                               &window_snapshot_component)) {
-    int sequence_number = static_cast<int>(
-        window_snapshot_component.sequence_number);
-#if defined(OS_MACOSX)
-    // On Mac, when using CoreAnmation, there is a delay between when content
-    // is drawn to the screen, and when the snapshot will actually pick up
-    // that content. Insert a manual delay of 1/6th of a second (to simulate
-    // 10 frames at 60 fps) before actually taking the snapshot.
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&RenderWidgetHostImpl::WindowSnapshotReachedScreen,
-                   weak_factory_.GetWeakPtr(), sequence_number),
-        base::TimeDelta::FromSecondsD(1. / 6));
-#else
-    WindowSnapshotReachedScreen(sequence_number);
-#endif
-  }
-
-  latency_tracker_.OnFrameSwapped(latency_info);
-}
-
 void RenderWidgetHostImpl::DidReceiveRendererFrame() {
   view_->DidReceiveRendererFrame();
 }
 
 void RenderWidgetHostImpl::WindowSnapshotReachedScreen(int snapshot_id) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   if (!pending_surface_browser_snapshots_.empty()) {
     GetView()->CopyFromSurface(
         gfx::Rect(), gfx::Size(),
@@ skipping 70 matching lines @@
       ++it;
     }
   }
 #if defined(OS_MACOSX)
   if (pending_browser_snapshots_.empty())
     power_save_blocker_.reset();
 #endif
 }
 
 // static
-void RenderWidgetHostImpl::CompositorFrameDrawn(
+void RenderWidgetHostImpl::OnGpuSwapBufersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++) {
     std::set<RenderWidgetHostImpl*> rwhi_set;
     for (const auto& lc : latency_info[i].latency_components()) {
       if (lc.first.first == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
-          lc.first.first == ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT ||
+          lc.first.first == ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT ||
           lc.first.first == ui::TAB_SHOW_COMPONENT) {
         // Matches with GetLatencyComponentId
         int routing_id = lc.first.second & 0xffffffff;
         int process_id = (lc.first.second >> 32) & 0xffffffff;
         RenderWidgetHost* rwh =
             RenderWidgetHost::FromID(process_id, routing_id);
         if (!rwh) {
           continue;
         }
         RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
         if (rwhi_set.insert(rwhi).second)
-          rwhi->FrameSwapped(latency_info[i]);
+          rwhi->OnGpuSwapBufersCompletedInternal(latency_info[i]);
       }
     }
   }
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetRootBrowserAccessibilityManager() {
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
@@ skipping 166 matching lines @@
 
   // After navigation, if a frame belonging to the new page is received, stop
   // the timer that triggers clearing the graphics of the last page.
   if (last_received_content_source_id_ >= current_content_source_id_ &&
       new_content_rendering_timeout_->IsRunning()) {
     new_content_rendering_timeout_->Stop();
   }
 }
 
 }  // namespace content