Block incognito browser windows for voice interaction.

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_aura.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 namespace ui {
 
 bool GrabWindowSnapshotAura(aura::Window* window,
                             const gfx::Rect& snapshot_bounds,
                             gfx::Image* image) {
   // Not supported in Aura.  Callers should fall back to the async version.
   return false;
 }
 
 static void MakeAsyncCopyRequest(
-    aura::Window* window,
+    Layer* layer,
     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));
+  layer->RequestCopyOfOutput(std::move(request));
 }
 
 static void FinishedAsyncCopyRequest(
     std::unique_ptr<aura::WindowTracker> tracker,
     const gfx::Rect& source_rect,
     const cc::CopyOutputRequest::CopyOutputRequestCallback& callback,
     int retry_count,
     std::unique_ptr<cc::CopyOutputResult> result) {
   static const int kMaxRetries = 5;
   // Retry the copy request if the previous one failed for some reason.
   if (!tracker->windows().empty() && (retry_count < kMaxRetries) &&
       result->IsEmpty()) {
     // Look up window before calling MakeAsyncRequest. Otherwise, due
     // to undefined (favorably right to left) argument evaluation
     // order, the tracker might have been passed and set to NULL
     // before the window is looked up which results in a NULL pointer
     // dereference.
     aura::Window* window = tracker->windows()[0];
     MakeAsyncCopyRequest(
-        window, source_rect,
+        window->layer(), source_rect,
         base::Bind(&FinishedAsyncCopyRequest, base::Passed(&tracker),
                    source_rect, callback, retry_count + 1));
     return;
   }
 
   callback.Run(std::move(result));
 }
 
 static void MakeInitialAsyncCopyRequest(
     aura::Window* window,
     const gfx::Rect& source_rect,
     const cc::CopyOutputRequest::CopyOutputRequestCallback& callback) {
   auto tracker = base::MakeUnique<aura::WindowTracker>();
   tracker->Add(window);
   MakeAsyncCopyRequest(
-      window, source_rect,
+      window->layer(), source_rect,
       base::Bind(&FinishedAsyncCopyRequest, base::Passed(&tracker), source_rect,
                  callback, 0));
 }
 
 void GrabWindowSnapshotAndScaleAsyncAura(
     aura::Window* window,
     const gfx::Rect& source_rect,
     const gfx::Size& target_size,
     scoped_refptr<base::TaskRunner> background_task_runner,
     const GrabWindowSnapshotAsyncCallback& callback) {
@@ skipping 41 matching lines @@
                              const GrabWindowSnapshotAsyncCallback& callback) {
   GrabWindowSnapshotAsyncAura(window, source_rect, callback);
 }
 
 void GrabViewSnapshotAsync(gfx::NativeView view,
                            const gfx::Rect& source_rect,
                            const GrabWindowSnapshotAsyncCallback& callback) {
   GrabWindowSnapshotAsyncAura(view, source_rect, callback);
 }
 
+void GrabLayerSnapshotAsync(ui::Layer* layer,
+                            const gfx::Rect& source_rect,
+                            const GrabLayerSnapshotCallback& callback) {
+  MakeAsyncCopyRequest(
+      layer, source_rect,
+      base::Bind(&SnapshotAsync::RunCallbackWithCopyOutputResult, callback));
+}
+
 #endif
 
 }  // namespace ui