Change AckEvent into request / response

mojo/services/native_viewport/native_viewport_service.cc

 // Copyright 2013 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 "mojo/services/native_viewport/native_viewport_service.h"
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "mojo/public/bindings/allocation_scope.h"
@@ skipping 15 matching lines @@
 }
 
 }
 
 class NativeViewportImpl
     : public Service<mojo::NativeViewport, NativeViewportImpl, shell::Context>,
       public NativeViewportDelegate {
  public:
   NativeViewportImpl()
       : widget_(gfx::kNullAcceleratedWidget),
-        waiting_for_event_ack_(false),
-        pending_event_timestamp_(0) {}
+        waiting_for_event_ack_(false) {}
   virtual ~NativeViewportImpl() {}
 
   virtual void Create(const Rect& bounds) OVERRIDE {
     native_viewport_ =
         services::NativeViewport::Create(context(), this);
     native_viewport_->Init(bounds);
     client()->OnCreated();
     OnBoundsChanged(bounds);
   }
 
@@ skipping 27 matching lines @@
     // TODO(darin):
     // CreateGLES2Context should accept a ScopedCommandBufferClientHandle once
     // it is possible to import interface definitions from another module.  For
     // now, we just kludge it.
     command_buffer_handle_.reset(
         InterfaceHandle<CommandBufferClient>(client_handle.release().value()));
 
     CreateCommandBufferIfNeeded();
   }
 
-  virtual void AckEvent(const Event& event) OVERRIDE {
-    DCHECK_EQ(event.time_stamp(), pending_event_timestamp_);
+  void AckEvent() {
     waiting_for_event_ack_ = false;
   }
 
   void CreateCommandBufferIfNeeded() {
     if (!command_buffer_handle_.is_valid())
       return;
     DCHECK(!command_buffer_.get());
     if (widget_ == gfx::kNullAcceleratedWidget)
       return;
     gfx::Size size = native_viewport_->GetSize();
@@ skipping 14 matching lines @@
     case ui::ET_TOUCH_RELEASED:
       native_viewport_->ReleaseCapture();
       break;
     default:
       break;
     }
 
     if (waiting_for_event_ack_ && IsRateLimitedEventType(ui_event))
       return false;
 
-    pending_event_timestamp_ = ui_event->time_stamp().ToInternalValue();
     AllocationScope scope;
 
     Event::Builder event;
     event.set_action(ui_event->type());
     event.set_flags(ui_event->flags());
-    event.set_time_stamp(pending_event_timestamp_);
+    event.set_time_stamp(ui_event->time_stamp().ToInternalValue());
 
     if (ui_event->IsMouseEvent() || ui_event->IsTouchEvent()) {
       ui::LocatedEvent* located_event =
           static_cast<ui::LocatedEvent*>(ui_event);
       Point::Builder location;
       location.set_x(located_event->location().x());
       location.set_y(located_event->location().y());
       event.set_location(location.Finish());
     }
 
     if (ui_event->IsTouchEvent()) {
       ui::TouchEvent* touch_event = static_cast<ui::TouchEvent*>(ui_event);
       TouchData::Builder touch_data;
       touch_data.set_pointer_id(touch_event->touch_id());
       event.set_touch_data(touch_data.Finish());
     } else if (ui_event->IsKeyEvent()) {
       ui::KeyEvent* key_event = static_cast<ui::KeyEvent*>(ui_event);
       KeyData::Builder key_data;
       key_data.set_key_code(key_event->key_code());
       key_data.set_is_char(key_event->is_char());
       event.set_key_data(key_data.Finish());
     }
 
-    client()->OnEvent(event.Finish());
+    client()->OnEvent(event.Finish(),
+                      base::Bind(&NativeViewportImpl::AckEvent,
+                                 base::Unretained(this)));
     waiting_for_event_ack_ = true;
     return false;
   }
 
   virtual void OnAcceleratedWidgetAvailable(
       gfx::AcceleratedWidget widget) OVERRIDE {
     widget_ = widget;
     CreateCommandBufferIfNeeded();
   }
 
   virtual void OnBoundsChanged(const gfx::Rect& bounds) OVERRIDE {
     CreateCommandBufferIfNeeded();
     AllocationScope scope;
     client()->OnBoundsChanged(bounds);
   }
 
   virtual void OnDestroyed() OVERRIDE {
     command_buffer_.reset();
     client()->OnDestroyed();
     base::MessageLoop::current()->Quit();
   }
 
  private:
   gfx::AcceleratedWidget widget_;
   scoped_ptr<services::NativeViewport> native_viewport_;
   ScopedCommandBufferClientHandle command_buffer_handle_;
   scoped_ptr<CommandBufferImpl> command_buffer_;
   bool waiting_for_event_ack_;
-  int64 pending_event_timestamp_;
 };
 
 }  // namespace services
 }  // namespace mojo
 
 
 #if defined(OS_ANDROID)
 
 // Android will call this.
 MOJO_NATIVE_VIEWPORT_EXPORT mojo::Application*
@@ skipping 13 matching lines @@
   base::MessageLoopForUI loop;
   mojo::Application app(shell_handle);
   app.AddServiceFactory(
     new mojo::ServiceFactory<mojo::services::NativeViewportImpl,
                              mojo::shell::Context>);
   loop.Run();
   return MOJO_RESULT_OK;
 }
 
 #endif // !OS_ANDROID