NativeViewport

mojo/shell/app_container.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/shell/app_container.h"
 
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/native_library.h"
+#include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "mojo/public/system/core.h"
+#include "mojo/services/native_viewport/native_viewport.h"
+#include "mojo/services/native_viewport/native_viewport_delegate.h"
 #include "mojo/shell/context.h"
+#include "ui/events/event.h"
 
 typedef MojoResult (*MojoMainFunction)(mojo::Handle pipe);
 
 namespace mojo {
 namespace shell {
 
+// TODO(beng): This should move with the rest of the NativeViewportService
+//             once we have a specific pipe/API.
+class ShellNativeViewportDelegate : public services::NativeViewportDelegate {

[abarth-chromium, 2013/10/29 21:48:44]

Yeah, it's kind of lame to have this here.  Can we put this class in
mojo/services/native_viewport and hand it a Handle for now?  In the future, we'd
want to hand it a Pipe or something.

+ public:
+  explicit ShellNativeViewportDelegate(Handle shell_handle)
+      : shell_handle_(shell_handle) {}
+  virtual ~ShellNativeViewportDelegate() {}
+
+ private:
+  // Overridden from services::NativeViewportDelegate:
+  virtual bool OnEvent(ui::Event* event) OVERRIDE {
+    ui::LocatedEvent* located = static_cast<ui::LocatedEvent*>(event);
+    SendString(base::StringPrintf("Event @ %d,%d",
+                                  located->location().x(),
+                                  located->location().y()));
+    return false;
+  }
+  virtual void OnResized(const gfx::Size& size) OVERRIDE {
+    SendString(base::StringPrintf("Sized to: %d x %d",
+                                  size.width(),
+                                  size.height()));
+  }
+
+  void SendString(const std::string& string) {
+    MojoResult result = WriteMessage(
+        shell_handle_, string.c_str(), string.size()+1, NULL, 0,
+        MOJO_WRITE_MESSAGE_FLAG_NONE);
+    if (result < MOJO_RESULT_OK) {
+      // Failure.
+    }
+  }
+
+  Handle shell_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShellNativeViewportDelegate);
+};
+
 void LaunchAppOnThread(
     const base::FilePath& app_path,
     Handle app_handle) {
   MojoResult result = MOJO_RESULT_OK;
   MojoMainFunction main_function = NULL;
 
   base::NativeLibrary app_library = base::LoadNativeLibrary(app_path, NULL);
   if (!app_library) {
     LOG(ERROR) << "Failed to load library: " << app_path.value().c_str();
     goto completed;
@@ skipping 50 matching lines @@
       base::Bind(&LaunchAppOnThread, app_path, app_handle),
       base::Bind(&AppContainer::AppCompleted, weak_factory_.GetWeakPtr()));
 
   const char* hello_msg = "Hello";
   result = WriteMessage(shell_handle_, hello_msg,
                         static_cast<uint32_t>(strlen(hello_msg)+1),
                         NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
   if (result < MOJO_RESULT_OK) {
     // Failure..
   }
+
+  // TODO(beng): This should be created on demand by the NativeViewportService
+  //             when it is retrieved by the app.
+  ShellNativeViewportDelegate* delegate =
+      new ShellNativeViewportDelegate(shell_handle_);
+  services::NativeViewport* viewport =
+      services::NativeViewport::CreateNativeViewport(delegate);

[abarth-chromium, 2013/10/29 21:48:44]

These leak, right?  Maybe we should store them in scoped_ptrs in the
AppContainer?

I wonder if we should do something like we do in pepper where every object is
associated with an instance so that they can all be freed when the instance
dies.

 }
 
 void AppContainer::AppCompleted() {
   thread_.reset();
   Close(shell_handle_);
 
   // Probably want to do something more sophisticated here, like notify someone
   // else to do this.
   base::MessageLoop::current()->Quit();
 }
 
 }  // namespace shell
 }  // namespace mojo