Here are gyp targets and stubs for compiling libcc and the webkit_compositor bindings in chromium. Everything is guarded behind the off-by-default use_libcc_for_compositor gyp variable. I haven't included the actual code here, but there are scripts to sync. I plan to land + manually sync the code into place until we're ready to flip the gyp switch.

Snapshot from r126652

BUG=

Review URL: https://chromiumcodereview.appspot.com/10828381

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@153354 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 78 insertions, 0 deletions

diff --git a/cc/CCDelayBasedTimeSource.h b/cc/CCDelayBasedTimeSource.h
new file mode 100644
index 0000000..9565983
--- /dev/null
+++ b/cc/CCDelayBasedTimeSource.h
@@ -0,0 +1,78 @@
+// Copyright 2011 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.
+
+#ifndef CCDelayBasedTimeSource_h
+#define CCDelayBasedTimeSource_h
+
+#include "CCTimeSource.h"
+#include "CCTimer.h"
+#include <wtf/PassRefPtr.h>
+
+namespace WebCore {
+
+class CCThread;
+
+// This timer implements a time source that achieves the specified interval
+// in face of millisecond-precision delayed callbacks and random queueing delays.
+class CCDelayBasedTimeSource : public CCTimeSource, CCTimerClient {
+public:
+    static PassRefPtr<CCDelayBasedTimeSource> create(double intervalSeconds, CCThread*);
+
+    virtual ~CCDelayBasedTimeSource() { }
+
+    virtual void setClient(CCTimeSourceClient* client) OVERRIDE { m_client = client; }
+
+    // CCTimeSource implementation
+    virtual void setTimebaseAndInterval(double timebase, double intervalSeconds) OVERRIDE;
+
+    virtual void setActive(bool) OVERRIDE;
+    virtual bool active() const OVERRIDE { return m_state != STATE_INACTIVE; }
+
+    // Get the last and next tick times.
+    virtual double lastTickTime() OVERRIDE;
+    virtual double nextTickTimeIfActivated() OVERRIDE;
+
+    // CCTimerClient implementation.
+    virtual void onTimerFired() OVERRIDE;
+
+    // Virtual for testing.
+    virtual double monotonicTimeNow() const;
+
+protected:
+    CCDelayBasedTimeSource(double interval, CCThread*);
+    double nextTickTarget(double now);
+    void postNextTickTask(double now);
+
+    enum State {
+        STATE_INACTIVE,
+        STATE_STARTING,
+        STATE_ACTIVE,
+    };
+
+    struct Parameters {
+        Parameters(double interval, double tickTarget)
+            : interval(interval), tickTarget(tickTarget)
+        { }
+        double interval;
+        double tickTarget;
+    };
+
+    CCTimeSourceClient* m_client;
+    bool m_hasTickTarget;
+    double m_lastTickTime;
+
+    // m_currentParameters should only be written by postNextTickTask.
+    // m_nextParameters will take effect on the next call to postNextTickTask.
+    // Maintaining a pending set of parameters allows nextTickTime() to always
+    // reflect the actual time we expect onTimerFired to be called.
+    Parameters m_currentParameters;
+    Parameters m_nextParameters;
+
+    State m_state;
+    CCThread* m_thread;
+    CCTimer m_timer;
+};
+
+}
+#endif // CCDelayBasedTimeSource_h