Repeat window snapshot copy request on failure

ui/snapshot/snapshot_aura.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 "ui/snapshot/snapshot.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/task_runner_util.h"
 #include "cc/output/copy_output_request.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_observer.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/snapshot/snapshot_async.h"
 
 namespace ui {
 
+namespace {
+
+class WindowCapturer : public aura::WindowObserver {
+ public:
+  WindowCapturer(aura::Window* window) : window_(window) {

[sadrul, 2016/09/29 04:45:09]

explicit

+    window_->AddObserver(this);
+  }
+  ~WindowCapturer() override {
+    if (window_)
+      window_->RemoveObserver(this);
+  }
+
+  void OnWindowDestroyed(aura::Window* window) override { window_ = nullptr; }
+  aura::Window* window() const { return window_; }
+
+ private:
+  aura::Window* window_;

[sadrul, 2016/09/29 04:45:09]

DISALLOW_COPY_AND_ASSIGN

+};
+
+}  // namespace
+
 bool GrabViewSnapshot(gfx::NativeView view,
                       std::vector<unsigned char>* png_representation,
                       const gfx::Rect& snapshot_bounds) {
   return GrabWindowSnapshot(view, png_representation, snapshot_bounds);
 }
 
 bool GrabWindowSnapshot(gfx::NativeWindow window,
                         std::vector<unsigned char>* png_representation,
                         const gfx::Rect& snapshot_bounds) {
   // Not supported in Aura.  Callers should fall back to the async version.
   return false;
 }
 
 static void MakeAsyncCopyRequest(
     gfx::NativeWindow window,
     const gfx::Rect& source_rect,
     const cc::CopyOutputRequest::CopyOutputRequestCallback& callback) {
   std::unique_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateBitmapRequest(callback);
   request->set_area(source_rect);
   window->layer()->RequestCopyOfOutput(std::move(request));
 }
 
+static void FinishedAsyncCopyRequest(
+    std::unique_ptr<WindowCapturer> capturer,
+    const gfx::Rect& source_rect,
+    const cc::CopyOutputRequest::CopyOutputRequestCallback& callback,
+    int retry_count,
+    std::unique_ptr<cc::CopyOutputResult> result) {
+  static const int kMaxRetries = 5;
+  aura::Window* window = capturer->window();
+
+  // Retry the copy request if the previous one failed for some reason.
+  if (window && (retry_count < kMaxRetries) && result->IsEmpty()) {
+    MakeAsyncCopyRequest(

[sadrul, 2016/09/29 04:45:09]

Do we want to delay this request? Does the failure happen quickly enough that we
may be issuing too many retries too quickly? Would that be problematic, e.g.
cause the system ui to freeze?

+        window, source_rect,
+        base::Bind(&FinishedAsyncCopyRequest, base::Passed(&capturer),
+                   source_rect, callback, retry_count + 1));
+    return;
+  }
+
+  callback.Run(std::move(result));
+}
+
+static void MakeInitialAsyncCopyRequest(
+    gfx::NativeWindow window,
+    const gfx::Rect& source_rect,
+    const cc::CopyOutputRequest::CopyOutputRequestCallback& callback) {
+  std::unique_ptr<WindowCapturer> capturer =
+      base::MakeUnique<WindowCapturer>(window);

[sadrul, 2016/09/29 04:45:09]

You can use aura::WindowTracker if you want instead.

+  MakeAsyncCopyRequest(
+      window, source_rect,
+      base::Bind(&FinishedAsyncCopyRequest, base::Passed(&capturer),
+                 source_rect, callback, 0));
+}
+
 void GrabWindowSnapshotAndScaleAsync(
     gfx::NativeWindow window,
     const gfx::Rect& source_rect,
     const gfx::Size& target_size,
     scoped_refptr<base::TaskRunner> background_task_runner,
     const GrabWindowSnapshotAsyncCallback& callback) {
-  MakeAsyncCopyRequest(window,
-                       source_rect,
-                       base::Bind(&SnapshotAsync::ScaleCopyOutputResult,
-                                  callback,
-                                  target_size,
-                                  background_task_runner));
+  MakeInitialAsyncCopyRequest(
+      window, source_rect,
+      base::Bind(&SnapshotAsync::ScaleCopyOutputResult, callback, target_size,
+                 background_task_runner));
 }
 
 void GrabWindowSnapshotAsync(
     gfx::NativeWindow window,
     const gfx::Rect& source_rect,
     scoped_refptr<base::TaskRunner> background_task_runner,
     const GrabWindowSnapshotAsyncPNGCallback& callback) {
-  MakeAsyncCopyRequest(window,
-                       source_rect,
-                       base::Bind(&SnapshotAsync::EncodeCopyOutputResult,
-                                  callback,
-                                  background_task_runner));
+  MakeInitialAsyncCopyRequest(window, source_rect,
+                              base::Bind(&SnapshotAsync::EncodeCopyOutputResult,
+                                         callback, background_task_runner));
 }
 
 void GrabViewSnapshotAsync(
     gfx::NativeView view,
     const gfx::Rect& source_rect,
     scoped_refptr<base::TaskRunner> background_task_runner,
     const GrabWindowSnapshotAsyncPNGCallback& callback) {
   GrabWindowSnapshotAsync(view, source_rect, background_task_runner, callback);
 }
 
 
 }  // namespace ui