[Linux] Show preview contents for minimized windows

ui/compositor/compositor.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/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 65 matching lines @@
       widget_(widget),
       compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       disable_schedule_composite_(false),
       compositor_lock_(NULL),
       defer_draw_scheduling_(false),
+      block_drawing_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       swap_state_(SWAP_NONE),
       layer_animator_collection_(this),
       schedule_draw_factory_(this) {
   root_web_layer_ = cc::Layer::Create();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
@@ skipping 84 matching lines @@
   if (compositor_thread_loop_.get()) {
     host_->SetNeedsCommit();
   } else if (!defer_draw_scheduling_) {
     defer_draw_scheduling_ = true;
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Compositor::Draw, schedule_draw_factory_.GetWeakPtr()));
   }
 }
 
+void Compositor::SetBlockDrawing(bool block_drawing) {
+  DCHECK(!compositor_thread_loop_);
+
+  if (block_drawing_ == block_drawing)
+    return;
+
+  block_drawing_ = block_drawing;
+  defer_draw_scheduling_ = block_drawing;
+
+  if (!block_drawing)
+    ScheduleDraw();
+}
+
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
   if (root_layer_)
     root_layer_->SetCompositor(NULL);
   root_layer_ = root_layer;
   if (root_layer_ && !root_layer_->GetCompositor())
     root_layer_->SetCompositor(this);
   root_web_layer_->RemoveAllChildren();
   if (root_layer_)
     root_web_layer_->AddChild(root_layer_->cc_layer());
 }
 
 void Compositor::SetHostHasTransparentBackground(
     bool host_has_transparent_background) {
   host_->set_has_transparent_background(host_has_transparent_background);
 }
 
 void Compositor::Draw() {
   DCHECK(!compositor_thread_loop_.get());
 
+  if (block_drawing_)
+    return;
+
   defer_draw_scheduling_ = false;
   if (waiting_on_compositing_end_) {
     draw_on_compositing_end_ = true;
     return;
   }
   if (!root_layer_)
     return;
 
   TRACE_EVENT_ASYNC_BEGIN0("ui", "Compositor::Draw", last_started_frame_ + 1);
 
@@ skipping 48 matching lines @@
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 void Compositor::SetBackgroundColor(SkColor color) {
   host_->set_background_color(color);
   ScheduleDraw();
 }
 
 void Compositor::SetVisible(bool visible) {

[danakj, 2014/09/05 15:03:15]

Why don't you just call this?

   host_->SetVisible(visible);
 }
 
 scoped_refptr<CompositorVSyncManager> Compositor::vsync_manager() const {
   return vsync_manager_;
 }
 
 void Compositor::AddObserver(CompositorObserver* observer) {
 #if defined(OS_MACOSX)
   // Debugging instrumentation for crbug.com/401630.
@@ skipping 154 matching lines @@
     // Call ScheduleDraw() instead of Draw() in order to allow other
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(
       CompositorObserver, observer_list_, OnCompositingEnded(this));
 }
 
 }  // namespace ui