Add Fade-out/Fade-in animation during output-configuration change.

chromeos/display/output_configurator.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 "chromeos/display/output_configurator.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/Xrandr.h>
 
 // Xlib defines Status as int which causes our include of dbus/bus.h to fail
 // when it tries to name an enum Status.  Thus, we need to undefine it (note
 // that this will cause a problem if code needs to use the Status type).
 // RootWindow causes similar problems in that there is a Chromium type with that
 // name.
 #undef Status
 #undef RootWindow
 
+#include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/message_pump_aurax11.h"
 #include "base/metrics/histogram.h"
 #include "base/perftimer.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "dbus/bus.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
@@ skipping 720 matching lines @@
   }
   return success;
 }
 
 bool OutputConfigurator::SetDisplayMode(State new_state) {
   if (output_state_ == STATE_INVALID ||
       output_state_ == STATE_HEADLESS ||
       output_state_ == STATE_SINGLE)
     return false;
 
-  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
-  CHECK(display != NULL);
-  XGrabServer(display);
-  Window window = DefaultRootWindow(display);
-  XRRScreenResources* screen = XRRGetScreenResources(display, window);
-  CHECK(screen != NULL);
-
-  UpdateCacheAndXrandrToState(display,
-                              screen,
-                              window,
-                              new_state);
-  XRRFreeScreenResources(screen);
-  XUngrabServer(display);
+  if (animation_delegate_.get()) {
+    animation_delegate_->WillDisplayModeChange(
+        base::Bind(&OutputConfigurator::SetDisplayModeInternal,
+                   base::Unretained(this), new_state));
+  } else {
+    SetDisplayModeInternal(new_state);
+  }
   return true;
 }
 
 bool OutputConfigurator::Dispatch(const base::NativeEvent& event) {
   // Ignore this event if the Xrandr extension isn't supported.
   if (is_running_on_chrome_os_ &&
       (event->type - xrandr_event_base_ == RRNotify)) {
     XEvent* xevent = static_cast<XEvent*>(event);
     XRRNotifyEvent* notify_event =
         reinterpret_cast<XRRNotifyEvent*>(xevent);
     if (notify_event->subtype == RRNotify_OutputChange) {
       XRROutputChangeNotifyEvent* output_change_event =
           reinterpret_cast<XRROutputChangeNotifyEvent*>(xevent);
       if ((output_change_event->connection == RR_Connected) ||
           (output_change_event->connection == RR_Disconnected)) {
         RecacheAndUseDefaultState();
         CheckIsProjectingAndNotify();
       }
       // Ignore the case of RR_UnkownConnection.
     }
   }
   return true;
 }
 
+void OutputConfigurator::SetDisplayModeInternal(State new_state) {
+  // We should have this guard both in SetDisplayMode and SetDisplayModeInternal
+  // because |output_state_| may change during the animation.
+  if (output_state_ == STATE_INVALID ||
+      output_state_ == STATE_HEADLESS ||
+      output_state_ == STATE_SINGLE) {
+    if (animation_delegate_.get()) {
+      MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&AnimationDelegate::OnDisplayModeChanged,
+                                base::Unretained(animation_delegate_.get())));
+    }
+    return;
+  }
+
+  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  CHECK(display != NULL);
+  XGrabServer(display);
+  Window window = DefaultRootWindow(display);
+  XRRScreenResources* screen = XRRGetScreenResources(display, window);
+  CHECK(screen != NULL);
+
+  UpdateCacheAndXrandrToState(display,
+                              screen,
+                              window,
+                              new_state);
+  XRRFreeScreenResources(screen);
+  XUngrabServer(display);
+  if (animation_delegate_.get()) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&AnimationDelegate::OnDisplayModeChanged,
+                              base::Unretained(animation_delegate_.get())));
+  }
+}
+
 void OutputConfigurator::CheckIsProjectingAndNotify() {
   // Determine if there is an "internal" output and how many outputs are
   // connected.
   bool has_internal_output = false;
   int connected_output_count = 0;
   for (int i = 0; i < output_count_; ++i) {
     if (output_cache_[i].is_connected) {
       connected_output_count += 1;
       has_internal_output |= output_cache_[i].is_internal;
     }
@@ skipping 12 matching lines @@
       power_manager::kSetIsProjectingMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendBool(is_projecting);
   power_manager_proxy->CallMethod(
       &method_call,
       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
       dbus::ObjectProxy::EmptyResponseCallback());
 }
 
 }  // namespace chromeos