Fix race conditions in window snapshot code.

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 <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
+#include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_process_host.h"
@@ skipping 22 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "ui/base/events/event.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/vector2d_conversions.h"
+#include "ui/snapshot/snapshot.h"
 #include "webkit/common/cursors/webcursor.h"
 #include "webkit/common/webpreferences.h"
 
 #if defined(TOOLKIT_GTK)
 #include "content/browser/renderer_host/backing_store_gtk.h"
 #elif defined(OS_MACOSX)
 #include "content/browser/renderer_host/backing_store_mac.h"
 #elif defined(OS_WIN)
 #include "content/common/plugin_constants_win.h"
 #endif
@@ skipping 98 matching lines @@
     // problem, for example by tracking in the RenderWidgetHelper the routing id
     // (and surface id) that have been created, but whose RWH haven't yet.
     surface_id_ = GpuSurfaceTracker::Get()->LookupSurfaceForRenderer(
         process_->GetID(),
         routing_id_);
     DCHECK(surface_id_);
   }
 
   is_threaded_compositing_enabled_ = IsThreadedCompositingEnabled();
 
+  LOG(INFO) << "RenderWidgetHostImpl: created for process id = " << process->GetID() << "  routing id = " << routing_id_;
+
   g_routing_id_widget_map.Get().insert(std::make_pair(
       RenderWidgetHostID(process->GetID(), routing_id_), this));
   process_->AddRoute(routing_id_, this);
 
   // If we're initially visible, tell the process host that we're alive.
   // Otherwise we'll notify the process host when we are first shown.
   if (!hidden)
     process_->WidgetRestored();
 
   accessibility_mode_ =
@@ skipping 2258 matching lines @@
         1000000,
         100);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuBenchmarking))
     Send(new ViewMsg_SetBrowserRenderingStats(routing_id_, rendering_stats_));
 }
 
 void RenderWidgetHostImpl::FrameSwapped(const ui::LatencyInfo& latency_info) {
+  LOG(INFO) << "RenderWidgetHostImpl::FrameSwapped";
+  ui::LatencyInfo::LatencyComponent window_snapshot_component;
+  if (latency_info.FindLatency(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
+                               GetLatencyComponentId(),
+                               &window_snapshot_component)) {
+    WindowSnapshotReachedScreen(
+        static_cast<int>(window_snapshot_component.sequence_number));
+  }
+
   ui::LatencyInfo::LatencyComponent rwh_component;
   if (!latency_info.FindLatency(ui::INPUT_EVENT_LATENCY_RWH_COMPONENT,
                                 GetLatencyComponentId(),
                                 &rwh_component))
     return;
 
   rendering_stats_.input_event_count += rwh_component.event_count;
   rendering_stats_.total_input_latency +=
       rwh_component.event_count *
       (latency_info.swap_timestamp - rwh_component.event_time);
@@ skipping 24 matching lines @@
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGpuBenchmarking))
     Send(new ViewMsg_SetBrowserRenderingStats(routing_id_, rendering_stats_));
 }
 
 void RenderWidgetHostImpl::DidReceiveRendererFrame() {
   view_->DidReceiveRendererFrame();
 }
 
+void RenderWidgetHostImpl::WindowSnapshotReachedScreen(int snapshot_id) {
+  LOG(INFO) << "RenderWidgetHostImpl::WindowSnapshotReachedScreen: " << snapshot_id;
+
+  DCHECK(base::MessageLoop::current()->IsType(base::MessageLoop::TYPE_UI));
+
+  std::vector<unsigned char> png;
+
+  // This feature is behind the kEnableGpuBenchmarking command line switch
+  // because it poses security concerns and should only be used for testing.
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();

[jbauman, 2013/09/13 22:33:24]

Can multiple snapshots be outstanding at once? If so, they could be coalesced
together into one swap, which means the snapshot with the lower number will be
ignored.

+  if (command_line.HasSwitch(switches::kEnableGpuBenchmarking)) {
+    gfx::Rect view_bounds = GetView()->GetViewBounds();
+    gfx::Rect snapshot_bounds(view_bounds.size());
+    gfx::Size snapshot_size = snapshot_bounds.size();
+
+    if (ui::GrabViewSnapshot(GetView()->GetNativeView(),
+                             &png, snapshot_bounds)) {
+      Send(new ViewMsg_WindowSnapshotCompleted(
+          GetRoutingID(), snapshot_id, snapshot_size, png));
+      return;
+    }
+  }
+
+  Send(new ViewMsg_WindowSnapshotCompleted(
+      GetRoutingID(), snapshot_id, gfx::Size(), png));
+}
+
 // static
 void RenderWidgetHostImpl::CompositorFrameDrawn(
     const ui::LatencyInfo& latency_info) {
+  LOG(INFO) << "RenderWidgetHostImpl::CompositorFrameDrawn top level";
   for (ui::LatencyInfo::LatencyMap::const_iterator b =
            latency_info.latency_components.begin();
        b != latency_info.latency_components.end();
        ++b) {
-    if (b->first.first != ui::INPUT_EVENT_LATENCY_RWH_COMPONENT)
+    if (b->first.first == ui::INPUT_EVENT_LATENCY_RWH_COMPONENT ||
+        b->first.first == ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT) {
+      // Matches with GetLatencyComponentId
+      int routing_id = b->first.second & 0xffffffff;
+      int process_id = (b->first.second >> 32) & 0xffffffff;
+      LOG(INFO) << "RenderWidgetHostImpl::CompositorFrameDrawn: type = " << (int) b->first.first << "  process id = " << process_id << "  routing_id = " << routing_id;
+      RenderWidgetHost* rwh =
+          RenderWidgetHost::FromID(process_id, routing_id);
+      if (!rwh) {
+        LOG(INFO) << "  (no such RenderWidgetHost)";
+        continue;
+      }
+      RenderWidgetHostImpl::From(rwh)->FrameSwapped(latency_info);

[jbauman, 2013/09/13 22:33:24]

You should probably make a set of RWHI to send the message to, or otherwise an
RWHI could get the same message twice, which could cause problems.

       continue;
-    // Matches with GetLatencyComponentId
-    int routing_id = b->first.second & 0xffffffff;
-    int process_id = (b->first.second >> 32) & 0xffffffff;
-    RenderWidgetHost* rwh =
-        RenderWidgetHost::FromID(process_id, routing_id);
-    if (!rwh)
-      continue;
-    RenderWidgetHostImpl::From(rwh)->FrameSwapped(latency_info);
+    }
   }
 }
 
 }  // namespace content