Add the xrender backend to the window manager.

compositor/real_compositor.cc

 // Copyright (c) 2010 The Chromium OS 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 "window_manager/compositor/compositor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 
 #include <gflags/gflags.h>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "window_manager/callback.h"
 #if defined(COMPOSITOR_OPENGL)
 #include "window_manager/compositor/gl/opengl_visitor.h"
 #elif defined(COMPOSITOR_OPENGLES)
 #include "window_manager/compositor/gles/opengles_visitor.h"
+#elif defined(COMPOSITOR_XRENDER)
+#include "window_manager/compositor/xrender/xrender_visitor.h"
 #endif
 #include "window_manager/compositor/layer_visitor.h"
 #include "window_manager/event_loop.h"
 #include "window_manager/image_container.h"
 #include "window_manager/profiler.h"
 #include "window_manager/util.h"
 #include "window_manager/x11/x_connection.h"
 
 DEFINE_bool(compositor_display_debug_needle, false,
             "Specify this to turn on a debugging aid for seeing when "
@@ skipping 569 matching lines @@
 }
 
 RealCompositor::Actor* RealCompositor::ImageActor::Clone() {
   ImageActor* new_instance = new ImageActor(compositor());
   QuadActor::CloneImpl(new_instance);
   return static_cast<Actor*>(new_instance);
 }
 
 void RealCompositor::ImageActor::SetImageData(
     const ImageContainer& image_container) {
-  compositor()->draw_visitor()->BindImage(&image_container, this);
+  compositor()->draw_visitor()->BindImage(image_container, this);
   SetSizeInternal(image_container.width(), image_container.height());
   SetDirty();
 }
 
 
 RealCompositor::TexturePixmapActor::TexturePixmapActor(
     RealCompositor* compositor)
     : RealCompositor::QuadActor(compositor),
       pixmap_(0),
       pixmap_is_opaque_(false) {
@@ skipping 77 matching lines @@
                     0, width(), height(), 0, 
                     -kProjectedDepthMin, -kProjectedDepthMax);
 }
 
 bool RealCompositor::StageActor::using_passthrough_projection() const {
   return true;
 }
 
 
 RealCompositor::RealCompositor(EventLoop* event_loop,
-                               XConnection* xconn,
+                               XConnection* xconn
 #if defined(COMPOSITOR_OPENGL)
-                               GLInterface* gl_interface
+                               ,GLInterface* gl_interface
 #elif defined(COMPOSITOR_OPENGLES)
-                               Gles2Interface* gl_interface
+                               ,Gles2Interface* gl_interface
 #endif
                               )
     : event_loop_(event_loop),
       x_conn_(xconn),
       dirty_(true),
       partially_dirty_(false),
       num_animations_(0),
       actor_count_(0),
       draw_timeout_id_(-1),
       draw_timeout_enabled_(false),
@@ skipping 14 matching lines @@
       new RealCompositor::StageActor(this,
                                      window,
                                      geometry.bounds.width,
                                      geometry.bounds.height));
 
   draw_visitor_.reset(
 #if defined(COMPOSITOR_OPENGL)
       new OpenGlDrawVisitor(gl_interface, this, default_stage_.get())
 #elif defined(COMPOSITOR_OPENGLES)
       new OpenGlesDrawVisitor(gl_interface, this, default_stage_.get())
+#elif defined(COMPOSITOR_XRENDER)
+      new XRenderDrawVisitor(this, default_stage_.get())
 #endif
       );
 
 #if defined(COMPOSITOR_OPENGL)
   if (!gl_interface->HasTextureFromPixmapExtension())
     texture_pixmap_actor_uses_fast_path_ = false;
 #endif
 
   draw_timeout_id_ = event_loop_->AddTimeout(
       NewPermanentCallback(this, &RealCompositor::Draw), 0,
@@ skipping 168 matching lines @@
 }
 
 void RealCompositor::DisableDrawTimeout() {
   if (draw_timeout_enabled_) {
     event_loop_->SuspendTimeout(draw_timeout_id_);
     draw_timeout_enabled_ = false;
   }
 }
 
 }  // namespace window_manager