Send size to NativeViewportClient::OnCreated instead of GLES2Client::DidCreateContext

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/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "mojo/services/gles2/gles2_impl.h"
 #include "mojo/services/native_viewport/native_viewport.h"
@@ skipping 13 matching lines @@
 }
 
 class NativeViewportService::NativeViewportImpl
     : public mojo::NativeViewport,
       public NativeViewportDelegate {
  public:
   NativeViewportImpl(NativeViewportService* service,
                      ScopedMessagePipeHandle client_handle)
       : service_(service),
         widget_(gfx::kNullAcceleratedWidget),
+        on_created_sent_(false),
         waiting_for_event_ack_(false),
         pending_event_timestamp_(0),
         client_(client_handle.Pass(), this) {
   }
   virtual ~NativeViewportImpl() {}
 
   virtual void Open() MOJO_OVERRIDE {
     native_viewport_ =
         services::NativeViewport::Create(service_->context_, this);
     native_viewport_->Init();
-    client_->OnCreated();
   }
 
   virtual void Close() MOJO_OVERRIDE {
     gles2_.reset();
     DCHECK(native_viewport_);
     native_viewport_->Close();
   }
 
   virtual void CreateGLES2Context(ScopedMessagePipeHandle client_handle)
       MOJO_OVERRIDE {
     gles2_.reset(new GLES2Impl(client_handle.Pass()));
     CreateGLES2ContextIfNeeded();
   }
 
   virtual void AckEvent(const Event& event) MOJO_OVERRIDE {
     DCHECK_EQ(event.time_stamp(), pending_event_timestamp_);
     waiting_for_event_ack_ = false;
   }
 
   void CreateGLES2ContextIfNeeded() {
-    if (widget_ == gfx::kNullAcceleratedWidget || !gles2_)
+    if (!on_created_sent_ || !gles2_)
       return;
+    DCHECK(widget_ != gfx::kNullAcceleratedWidget);
     gfx::Size size = native_viewport_->GetSize();
-    if (size.width() == 0 || size.height() == 0)
-      return;
+    DCHECK(!size.IsEmpty());
     gles2_->CreateContext(widget_, size);
   }
 
   virtual bool OnEvent(ui::Event* ui_event) MOJO_OVERRIDE {
     // Must not return early before updating capture.
     switch (ui_event->type()) {
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_TOUCH_PRESSED:
       native_viewport_->SetCapture();
       break;
@@ skipping 29 matching lines @@
       TouchData::Builder touch_data;
       touch_data.set_pointer_id(touch_event->touch_id());
       event.set_touch_data(touch_data.Finish());
     }
 
     client_->OnEvent(event.Finish());
     waiting_for_event_ack_ = true;
     return false;
   }
 
+  void MaybeSendOnCreated() {

[darin (slow to review), 2014/01/27 06:08:15]

nit: A name like SendOnCreatedIfNeeded is a bit more suggestive of what this
function does.

[piman, 2014/01/27 22:10:24]

Done.

+    if (widget_ == gfx::kNullAcceleratedWidget ||
+        on_created_sent_)
+      return;
+    gfx::Size size = native_viewport_->GetSize();
+    if (size.IsEmpty())
+      return;
+    on_created_sent_ = true;
+    client_->OnCreated(size.width(), size.height());
+    CreateGLES2ContextIfNeeded();
+  }
+
   virtual void OnAcceleratedWidgetAvailable(
       gfx::AcceleratedWidget widget) MOJO_OVERRIDE {
     widget_ = widget;
-    CreateGLES2ContextIfNeeded();
+    MaybeSendOnCreated();
   }
 
   virtual void OnResized(const gfx::Size& size) MOJO_OVERRIDE {
-    CreateGLES2ContextIfNeeded();
+    MaybeSendOnCreated();
   }
 
   virtual void OnDestroyed() MOJO_OVERRIDE {
     // TODO(beng):
     // Destroying |gles2_| on the shell thread here hits thread checker
     // asserts. All code must stop touching the AcceleratedWidget at this
     // point as it is dead after this call stack. jamesr said we probably
     // should make our own GLSurface and simply tell it to stop touching the
     // AcceleratedWidget via Destroy() but we have no good way of doing that
     // right now given our current threading model so james' recommendation
     // was just to wait until after we move the gl service out of process.
     // gles2_.reset();
     client_->OnDestroyed();
     base::MessageLoop::current()->Quit();
   }
 
  private:
   NativeViewportService* service_;
   gfx::AcceleratedWidget widget_;
   scoped_ptr<services::NativeViewport> native_viewport_;
   scoped_ptr<GLES2Impl> gles2_;
+  bool on_created_sent_;
   bool waiting_for_event_ack_;
   int64 pending_event_timestamp_;
 
   RemotePtr<NativeViewportClient> client_;
 };
 
 NativeViewportService::NativeViewportService(
     ScopedMessagePipeHandle shell_handle)
     : shell_(shell_handle.Pass(), this),
       context_(NULL) {
@@ skipping 24 matching lines @@
 extern "C" MOJO_NATIVE_VIEWPORT_EXPORT MojoResult MojoMain(
     const MojoHandle shell_handle) {
   base::MessageLoopForUI loop;
   mojo::services::NativeViewportService app(
       mojo::MakeScopedHandle(mojo::MessagePipeHandle(shell_handle)).Pass());
   base::MessageLoop::current()->Run();
   return MOJO_RESULT_OK;
 }
 
 #endif // !OS_ANDROID