Home | History | Annotate | Download | only in input 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_CONTROLLER_H_
      6 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_CONTROLLER_H_
      7 
      8 #include <queue>
      9 #include <utility>
     10 
     11 #include "base/callback.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/memory/scoped_vector.h"
     14 #include "base/time/time.h"
     15 #include "content/browser/renderer_host/input/synthetic_gesture.h"
     16 #include "content/common/content_export.h"
     17 #include "content/common/input/synthetic_gesture_params.h"
     18 
     19 namespace content {
     20 
     21 class SyntheticGestureTarget;
     22 
     23 // Controls a synthetic gesture.
     24 // Repeatedly invokes the gesture object's ForwardInputEvent method to send
     25 // input events to the platform until the gesture has finished.
     26 class CONTENT_EXPORT SyntheticGestureController {
     27  public:
     28   explicit SyntheticGestureController(
     29       scoped_ptr<SyntheticGestureTarget> gesture_target);
     30   virtual ~SyntheticGestureController();
     31 
     32   typedef base::Callback<void(SyntheticGesture::Result)>
     33       OnGestureCompleteCallback;
     34   void QueueSyntheticGesture(
     35       scoped_ptr<SyntheticGesture> synthetic_gesture,
     36       const OnGestureCompleteCallback& completion_callback);
     37 
     38   // Forward input events of the currently processed gesture.
     39   void Flush(base::TimeTicks timestamp);
     40 
     41   // To be called when all events generated from the current gesture have been
     42   // fully flushed from the input pipeline (i.e., sent, processed and ack'ed).
     43   void OnDidFlushInput();
     44 
     45  private:
     46   void StartGesture(const SyntheticGesture& gesture);
     47   void StopGesture(const SyntheticGesture& gesture,
     48                    const OnGestureCompleteCallback& completion_callback,
     49                    SyntheticGesture::Result result);
     50 
     51   scoped_ptr<SyntheticGestureTarget> gesture_target_;
     52   scoped_ptr<SyntheticGesture::Result> pending_gesture_result_;
     53 
     54   // A queue of gesture/callback pairs.  Implemented as two queues to
     55   // simplify the ownership of SyntheticGesture pointers.
     56   class GestureAndCallbackQueue {
     57   public:
     58     GestureAndCallbackQueue();
     59     ~GestureAndCallbackQueue();
     60     void Push(scoped_ptr<SyntheticGesture> gesture,
     61         const OnGestureCompleteCallback& callback) {
     62       gestures_.push_back(gesture.release());
     63       callbacks_.push(callback);
     64     }
     65     void Pop() {
     66       gestures_.erase(gestures_.begin());
     67       callbacks_.pop();
     68     }
     69     SyntheticGesture* FrontGesture() {
     70       return gestures_.front();
     71     }
     72     OnGestureCompleteCallback& FrontCallback() {
     73       return callbacks_.front();
     74     }
     75     bool IsEmpty() {
     76       CHECK(gestures_.empty() == callbacks_.empty());
     77       return gestures_.empty();
     78     }
     79    private:
     80     ScopedVector<SyntheticGesture> gestures_;
     81     std::queue<OnGestureCompleteCallback> callbacks_;
     82   } pending_gesture_queue_;
     83 
     84   DISALLOW_COPY_AND_ASSIGN(SyntheticGestureController);
     85 };
     86 
     87 }  // namespace content
     88 
     89 #endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_CONTROLLER_H_
     90