Gets aura_demo working with the view_manager

I made it talk directly to the view_manager. We'll likely want a
variant that talks to the client_lib too.

BUG=365012
TEST=covered by tests
R=ben@chromium.org

Review URL: https://codereview.chromium.org/313483002

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

mojo/examples/aura_demo/DEPS

 include_rules = [
+  "+cc",
+  "+skia/ext",
   "+ui/aura",
   "+ui/base/hit_test.h",
+  "+ui/compositor",
+  "+ui/events",
   "+ui/gfx",
 ]

mojo/examples/aura_demo/aura_demo.cc

@@ -5,13 +5,15 @@
 #include <stdio.h>
 #include <string>
 
+#include "base/bind.h"
 #include "mojo/aura/screen_mojo.h"
-#include "mojo/aura/window_tree_host_mojo.h"
+#include "mojo/examples/aura_demo/context_factory_view_manager.h"
+#include "mojo/examples/aura_demo/window_tree_host_view_manager.h"
 #include "mojo/public/cpp/application/application.h"
-#include "mojo/public/cpp/gles2/gles2.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/interfaces/service_provider/service_provider.mojom.h"
 #include "mojo/services/native_viewport/native_viewport.mojom.h"
+#include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
@@ -63,7 +65,7 @@ class DemoWindowDelegate : public aura::WindowDelegate {
   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {}
 
  private:
-  SkColor color_;
+  const SkColor color_;
 
   DISALLOW_COPY_AND_ASSIGN(DemoWindowDelegate);
 };
@@ -96,27 +98,73 @@ class DemoWindowTreeClient : public aura::client::WindowTreeClient {
   DISALLOW_COPY_AND_ASSIGN(DemoWindowTreeClient);
 };
 
+class AuraDemo;
+
+// Trivial IViewManagerClient implementation. Forwards to AuraDemo when
+// connection established.
+class IViewManagerClientImpl
+    : public InterfaceImpl<view_manager::IViewManagerClient> {
+ public:
+  explicit IViewManagerClientImpl(AuraDemo* aura_demo)
+      : aura_demo_(aura_demo) {}
+  virtual ~IViewManagerClientImpl() {}
+
+ private:
+  void OnResult(bool result) {
+    VLOG(1) << "IViewManagerClientImpl::::OnResult result=" << result;
+    DCHECK(result);
+  }
+
+  // IViewManagerClient:
+  virtual void OnViewManagerConnectionEstablished(
+      uint16_t connection_id,
+      uint32_t next_server_change_id,
+      mojo::Array<view_manager::INodePtr> nodes) OVERRIDE;
+  virtual void OnServerChangeIdAdvanced(
+      uint32_t next_server_change_id) OVERRIDE {
+  }
+  virtual void OnNodeBoundsChanged(uint32_t node,
+                                   mojo::RectPtr old_bounds,
+                                   mojo::RectPtr new_bounds) OVERRIDE {
+  }
+  virtual void OnNodeHierarchyChanged(
+      uint32_t node,
+      uint32_t new_parent,
+      uint32_t old_parent,
+      uint32_t server_change_id,
+      mojo::Array<view_manager::INodePtr> nodes) OVERRIDE {
+  }
+  virtual void OnNodeDeleted(uint32_t node, uint32_t server_change_id)
+      OVERRIDE {
+  }
+  virtual void OnNodeViewReplaced(uint32_t node,
+                                  uint32_t new_view_id,
+                                  uint32_t old_view_id) OVERRIDE {
+  }
+  virtual void OnViewDeleted(uint32_t view) OVERRIDE {
+  }
+
+  AuraDemo* aura_demo_;
+
+  DISALLOW_COPY_AND_ASSIGN(IViewManagerClientImpl);
+};
+
 class AuraDemo : public Application {
  public:
-  AuraDemo() {}
+  AuraDemo() {
+    AddService<IViewManagerClientImpl>(this);
+  }
   virtual ~AuraDemo() {}
 
-  virtual void Initialize() OVERRIDE {
+  void SetRoot(view_manager::IViewManager* view_manager, uint32_t node_id) {
+    context_factory_.reset(
+        new ContextFactoryViewManager(view_manager, node_id));
     aura::Env::CreateInstance(true);
+    aura::Env::GetInstance()->set_context_factory(context_factory_.get());
     screen_.reset(ScreenMojo::Create());
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
 
-    NativeViewportPtr native_viewport;
-    ConnectTo("mojo:mojo_native_viewport_service", &native_viewport);
-
-    window_tree_host_.reset(new WindowTreeHostMojo(
-        native_viewport.Pass(),
-        gfx::Rect(800, 600),
-        base::Bind(&AuraDemo::HostContextCreated, base::Unretained(this))));
-  }
-
- private:
-  void HostContextCreated() {
+    window_tree_host_.reset(new WindowTreeHostViewManager(gfx::Rect(800, 600)));
     window_tree_host_->InitHost();
 
     window_tree_client_.reset(
@@ -146,7 +194,11 @@ class AuraDemo : public Application {
     window_tree_host_->Show();
   }
 
-  mojo::GLES2Initializer gles2;
+  virtual void Initialize() OVERRIDE {
+  }
+
+  scoped_ptr<ContextFactoryViewManager> context_factory_;
+
   scoped_ptr<ScreenMojo> screen_;
 
   scoped_ptr<DemoWindowTreeClient> window_tree_client_;
@@ -164,6 +216,20 @@ class AuraDemo : public Application {
   DISALLOW_COPY_AND_ASSIGN(AuraDemo);
 };
 
+void IViewManagerClientImpl::OnViewManagerConnectionEstablished(
+      uint16_t connection_id,
+      uint32_t next_server_change_id,
+      mojo::Array<view_manager::INodePtr> nodes) {
+  const uint32_t view_id = connection_id << 16 | 1;
+  client()->CreateView(view_id, base::Bind(&IViewManagerClientImpl::OnResult,
+                                           base::Unretained(this)));
+  client()->SetView(nodes[0]->node_id, view_id,
+                    base::Bind(&IViewManagerClientImpl::OnResult,
+                               base::Unretained(this)));
+
+  aura_demo_->SetRoot(client(), view_id);
+}
+
 }  // namespace examples
 
 // static

mojo/examples/aura_demo/context_factory_view_manager.cc

+// Copyright 2014 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/examples/aura_demo/context_factory_view_manager.h"
+
+#include "base/bind.h"
+#include "cc/output/output_surface.h"
+#include "cc/output/software_output_device.h"
+#include "cc/resources/shared_bitmap_manager.h"
+#include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
+#include "skia/ext/platform_canvas.h"
+#include "ui/compositor/reflector.h"
+#include "ui/gfx/codec/png_codec.h"
+
+namespace mojo {
+namespace examples {
+namespace {
+
+void FreeSharedBitmap(cc::SharedBitmap* shared_bitmap) {
+  delete shared_bitmap->memory();
+}
+
+void IgnoreSharedBitmap(cc::SharedBitmap* shared_bitmap) {}
+
+bool CreateMapAndDupSharedBuffer(size_t size,
+                                 void** memory,
+                                 ScopedSharedBufferHandle* handle,
+                                 ScopedSharedBufferHandle* duped) {
+  MojoResult result = CreateSharedBuffer(NULL, size, handle);
+  if (result != MOJO_RESULT_OK)
+    return false;
+  DCHECK(handle->is_valid());
+
+  result = DuplicateBuffer(handle->get(), NULL, duped);
+  if (result != MOJO_RESULT_OK)
+    return false;
+  DCHECK(duped->is_valid());
+
+  result = MapBuffer(
+      handle->get(), 0, size, memory, MOJO_MAP_BUFFER_FLAG_NONE);
+  if (result != MOJO_RESULT_OK)
+    return false;
+  DCHECK(*memory);
+
+  return true;
+}
+
+class SoftwareOutputDeviceViewManager : public cc::SoftwareOutputDevice {
+ public:
+  explicit SoftwareOutputDeviceViewManager(
+      view_manager::IViewManager* view_manager,
+      uint32_t view_id)
+      : view_manager_(view_manager),
+        view_id_(view_id) {
+  }
+  virtual ~SoftwareOutputDeviceViewManager() {}
+
+  // cc::SoftwareOutputDevice:
+  virtual void EndPaint(cc::SoftwareFrameData* frame_data) OVERRIDE {
+    SetViewContents();
+
+    SoftwareOutputDevice::EndPaint(frame_data);
+  }
+
+ private:
+  void OnSetViewContentsDone(bool value) {
+    VLOG(1) << "SoftwareOutputDeviceManager::OnSetViewContentsDone " << value;
+    DCHECK(value);
+  }
+
+  void SetViewContents() {
+    std::vector<unsigned char> data;
+    gfx::PNGCodec::EncodeBGRASkBitmap(
+        skia::GetTopDevice(*canvas_)->accessBitmap(true), false, &data);
+
+    void* memory = NULL;
+    ScopedSharedBufferHandle duped;
+    bool result = CreateMapAndDupSharedBuffer(data.size(),
+                                              &memory,
+                                              &shared_state_handle_,
+                                              &duped);
+    if (!result)
+      return;
+
+    memcpy(memory, &data[0], data.size());
+
+    view_manager_->SetViewContents(
+        view_id_, duped.Pass(), static_cast<uint32_t>(data.size()),
+        base::Bind(&SoftwareOutputDeviceViewManager::OnSetViewContentsDone,
+                   base::Unretained(this)));
+  }
+
+  view_manager::IViewManager* view_manager_;
+  const uint32_t view_id_;
+  ScopedSharedBufferHandle shared_state_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(SoftwareOutputDeviceViewManager);
+};
+
+// TODO(sky): this is a copy from cc/test. Copy to a common place.
+class TestSharedBitmapManager : public cc::SharedBitmapManager {
+ public:
+  TestSharedBitmapManager() {}
+  virtual ~TestSharedBitmapManager() {}
+
+  virtual scoped_ptr<cc::SharedBitmap> AllocateSharedBitmap(
+      const gfx::Size& size) OVERRIDE {
+    base::AutoLock lock(lock_);
+    scoped_ptr<base::SharedMemory> memory(new base::SharedMemory);
+    memory->CreateAndMapAnonymous(size.GetArea() * 4);
+    cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+    bitmap_map_[id] = memory.get();
+    return scoped_ptr<cc::SharedBitmap>(
+        new cc::SharedBitmap(memory.release(), id,
+                             base::Bind(&FreeSharedBitmap)));
+  }
+
+  virtual scoped_ptr<cc::SharedBitmap> GetSharedBitmapFromId(
+      const gfx::Size&,
+      const cc::SharedBitmapId& id) OVERRIDE {
+    base::AutoLock lock(lock_);
+    if (bitmap_map_.find(id) == bitmap_map_.end())
+      return scoped_ptr<cc::SharedBitmap>();
+    return scoped_ptr<cc::SharedBitmap>(
+        new cc::SharedBitmap(bitmap_map_[id], id,
+                             base::Bind(&IgnoreSharedBitmap)));
+  }
+
+  virtual scoped_ptr<cc::SharedBitmap> GetBitmapForSharedMemory(
+      base::SharedMemory* memory) OVERRIDE {
+    base::AutoLock lock(lock_);
+    cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+    bitmap_map_[id] = memory;
+    return scoped_ptr<cc::SharedBitmap>(
+        new cc::SharedBitmap(memory, id, base::Bind(&IgnoreSharedBitmap)));
+  }
+
+ private:
+  base::Lock lock_;
+  std::map<cc::SharedBitmapId, base::SharedMemory*> bitmap_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSharedBitmapManager);
+};
+
+}  // namespace
+
+ContextFactoryViewManager::ContextFactoryViewManager(
+    view_manager::IViewManager* view_manager,
+    uint32_t view_id)
+    : view_manager_(view_manager),
+      view_id_(view_id),
+      shared_bitmap_manager_(new TestSharedBitmapManager()) {
+}
+
+ContextFactoryViewManager::~ContextFactoryViewManager() {}
+
+scoped_ptr<cc::OutputSurface> ContextFactoryViewManager::CreateOutputSurface(
+    ui::Compositor* compositor,
+    bool software_fallback) {
+  scoped_ptr<cc::SoftwareOutputDevice> output_device(
+      new SoftwareOutputDeviceViewManager(view_manager_, view_id_));
+  return make_scoped_ptr(new cc::OutputSurface(output_device.Pass()));
+}
+
+scoped_refptr<ui::Reflector> ContextFactoryViewManager::CreateReflector(
+    ui::Compositor* mirroed_compositor,
+    ui::Layer* mirroring_layer) {
+  return new ui::Reflector();
+}
+
+void ContextFactoryViewManager::RemoveReflector(
+    scoped_refptr<ui::Reflector> reflector) {
+}
+
+scoped_refptr<cc::ContextProvider>
+ContextFactoryViewManager::SharedMainThreadContextProvider() {
+  return scoped_refptr<cc::ContextProvider>(NULL);
+}
+
+void ContextFactoryViewManager::RemoveCompositor(ui::Compositor* compositor) {}
+
+bool ContextFactoryViewManager::DoesCreateTestContexts() { return false; }
+
+cc::SharedBitmapManager* ContextFactoryViewManager::GetSharedBitmapManager() {
+  return shared_bitmap_manager_.get();
+}
+
+base::MessageLoopProxy* ContextFactoryViewManager::GetCompositorMessageLoop() {
+  return NULL;
+}
+
+}  // namespace examples
+}  // namespace mojo

mojo/examples/aura_demo/context_factory_view_manager.h

+// Copyright 2014 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 MOJO_EXAMPLES_AURA_DEMO_CONTEXT_FACTORY_VIEW_MANAGER_H_
+#define MOJO_EXAMPLES_AURA_DEMO_CONTEXT_FACTORY_VIEW_MANAGER_H_
+
+#include "ui/compositor/compositor.h"
+
+namespace mojo {
+namespace view_manager {
+class IViewManager;
+}
+namespace examples {
+
+class ContextFactoryViewManager : public ui::ContextFactory {
+ public:
+  ContextFactoryViewManager(view_manager::IViewManager* view_manager,
+                            uint32_t view_id);
+  virtual ~ContextFactoryViewManager();
+
+ private:
+  // ContextFactory:
+  virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(
+      ui::Compositor* compositor,
+      bool software_fallback) OVERRIDE;
+  virtual scoped_refptr<ui::Reflector> CreateReflector(
+      ui::Compositor* mirrored_compositor,
+      ui::Layer* mirroring_layer) OVERRIDE;
+  virtual void RemoveReflector(scoped_refptr<ui::Reflector> reflector) OVERRIDE;
+  virtual scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider()
+      OVERRIDE;
+  virtual void RemoveCompositor(ui::Compositor* compositor) OVERRIDE;
+  virtual bool DoesCreateTestContexts() OVERRIDE;
+  virtual cc::SharedBitmapManager* GetSharedBitmapManager() OVERRIDE;
+  virtual base::MessageLoopProxy* GetCompositorMessageLoop() OVERRIDE;
+
+  view_manager::IViewManager* view_manager_;
+  const uint32_t view_id_;
+  scoped_ptr<cc::SharedBitmapManager> shared_bitmap_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ContextFactoryViewManager);
+};
+
+}  // namespace examples
+}  // namespace mojo
+
+#endif  // MOJO_EXAMPLES_AURA_DEMO_CONTEXT_FACTORY_VIEW_MANAGER_H_

mojo/examples/aura_demo/view_manager_init.cc

+// Copyright 2014 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 "base/basictypes.h"
+#include "base/bind.h"
+#include "mojo/public/cpp/application/application.h"
+#include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
+
+namespace mojo {
+namespace examples {
+
+// ViewManagerInit is responsible for establishing the initial connection to
+// the view manager. When established it loads |mojo_aura_demo|.
+class ViewManagerInit : public Application {
+ public:
+  ViewManagerInit() {}
+  virtual ~ViewManagerInit() {}
+
+  virtual void Initialize() OVERRIDE {
+    ConnectTo("mojo:mojo_view_manager", &view_manager_init_);
+    view_manager_init_->Connect("mojo:mojo_aura_demo",
+                                base::Bind(&ViewManagerInit::DidConnect,
+                                           base::Unretained(this)));
+  }
+
+ private:
+  void DidConnect(bool result) {
+    DCHECK(result);
+    VLOG(1) << "ViewManagerInit::DidConnection result=" << result;
+  }
+
+  view_manager::IViewManagerInitPtr view_manager_init_;
+
+  DISALLOW_COPY_AND_ASSIGN(ViewManagerInit);
+};
+
+}  // namespace examples
+
+// static
+Application* Application::Create() {
+  return new examples::ViewManagerInit();
+}
+
+}  // namespace mojo
+

mojo/examples/aura_demo/window_tree_host_view_manager.cc

+// Copyright 2014 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/examples/aura_demo/window_tree_host_view_manager.h"
+
+#include "ui/aura/window.h"
+#include "ui/aura/window_event_dispatcher.h"
+#include "ui/events/event.h"
+#include "ui/events/event_constants.h"
+
+namespace mojo {
+namespace examples {
+
+////////////////////////////////////////////////////////////////////////////////
+// WindowTreeHostViewManager, public:
+
+WindowTreeHostViewManager::WindowTreeHostViewManager(const gfx::Rect& bounds)
+    : bounds_(bounds) {
+  CreateCompositor(GetAcceleratedWidget());
+}
+
+WindowTreeHostViewManager::~WindowTreeHostViewManager() {
+  DestroyCompositor();
+  DestroyDispatcher();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WindowTreeHostViewManager, aura::WindowTreeHost implementation:
+
+ui::EventSource* WindowTreeHostViewManager::GetEventSource() {
+  return this;
+}
+
+gfx::AcceleratedWidget WindowTreeHostViewManager::GetAcceleratedWidget() {
+  NOTIMPLEMENTED() << "GetAcceleratedWidget";
+  return gfx::kNullAcceleratedWidget;
+}
+
+void WindowTreeHostViewManager::Show() {
+  window()->Show();
+}
+
+void WindowTreeHostViewManager::Hide() {
+}
+
+gfx::Rect WindowTreeHostViewManager::GetBounds() const {
+  return bounds_;
+}
+
+void WindowTreeHostViewManager::SetBounds(const gfx::Rect& bounds) {
+}
+
+gfx::Point WindowTreeHostViewManager::GetLocationOnNativeScreen() const {
+  return gfx::Point(0, 0);
+}
+
+void WindowTreeHostViewManager::SetCapture() {
+  NOTIMPLEMENTED();
+}
+
+void WindowTreeHostViewManager::ReleaseCapture() {
+  NOTIMPLEMENTED();
+}
+
+void WindowTreeHostViewManager::PostNativeEvent(
+    const base::NativeEvent& native_event) {
+  NOTIMPLEMENTED();
+}
+
+void WindowTreeHostViewManager::OnDeviceScaleFactorChanged(
+    float device_scale_factor) {
+  NOTIMPLEMENTED();
+}
+
+void WindowTreeHostViewManager::SetCursorNative(gfx::NativeCursor cursor) {
+  NOTIMPLEMENTED();
+}
+
+void WindowTreeHostViewManager::MoveCursorToNative(const gfx::Point& location) {
+  NOTIMPLEMENTED();
+}
+
+void WindowTreeHostViewManager::OnCursorVisibilityChangedNative(bool show) {
+  NOTIMPLEMENTED();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WindowTreeHostViewManager, ui::EventSource implementation:
+
+ui::EventProcessor* WindowTreeHostViewManager::GetEventProcessor() {
+  return dispatcher();
+}
+
+}  // namespace examples
+}  // namespace mojo

mojo/examples/aura_demo/window_tree_host_view_manager.h

+// Copyright 2014 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 MOJO_EXAMPLES_AURA_DEMO_WINDOW_TREE_HOST_VIEW_MANAGER_H_
+#define MOJO_EXAMPLES_AURA_DEMO_WINDOW_TREE_HOST_VIEW_MANAGER_H_
+
+#include "ui/aura/window_tree_host.h"
+#include "ui/events/event_source.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace mojo {
+namespace examples {
+
+class WindowTreeHostViewManager : public aura::WindowTreeHost,
+                                  public ui::EventSource {
+ public:
+  explicit WindowTreeHostViewManager(const gfx::Rect& bounds);
+  virtual ~WindowTreeHostViewManager();
+
+  const gfx::Rect& bounds() const { return bounds_; }
+
+ private:
+  // WindowTreeHost:
+  virtual ui::EventSource* GetEventSource() OVERRIDE;
+  virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
+  virtual void Show() OVERRIDE;
+  virtual void Hide() OVERRIDE;
+  virtual gfx::Rect GetBounds() const OVERRIDE;
+  virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
+  virtual gfx::Point GetLocationOnNativeScreen() const OVERRIDE;
+  virtual void SetCapture() OVERRIDE;
+  virtual void ReleaseCapture() OVERRIDE;
+  virtual void PostNativeEvent(const base::NativeEvent& native_event) OVERRIDE;
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
+  virtual void SetCursorNative(gfx::NativeCursor cursor) OVERRIDE;
+  virtual void MoveCursorToNative(const gfx::Point& location) OVERRIDE;
+  virtual void OnCursorVisibilityChangedNative(bool show) OVERRIDE;
+
+  // ui::EventSource:
+  virtual ui::EventProcessor* GetEventProcessor() OVERRIDE;
+
+  gfx::Rect bounds_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowTreeHostViewManager);
+};
+
+}  // namespace examples
+}  // namespace mojo
+
+#endif  // MOJO_EXAMPLES_AURA_DEMO_WINDOW_TREE_HOST_VIEW_MANAGER_H_

mojo/mojo.gyp

@@ -62,6 +62,7 @@
         ['use_aura==1', {
           'dependencies': [
             'mojo_aura_demo',
+            'mojo_aura_demo_init',
             'mojo_launcher',
             'mojo_demo_launcher',
             'mojo_embedded_app',

mojo/mojo_examples.gypi

@@ -170,22 +170,43 @@
           'type': 'shared_library',
           'dependencies': [
             '../base/base.gyp:base',
+            '../cc/cc.gyp:cc',
             '../ui/aura/aura.gyp:aura',
             '../ui/base/ui_base.gyp:ui_base',
+            '../ui/compositor/compositor.gyp:compositor',
             '../ui/gfx/gfx.gyp:gfx',
             '../ui/gfx/gfx.gyp:gfx_geometry',
+            'mojo_application',
             'mojo_aura_support',
-            'mojo_cc_support',
             'mojo_common_lib',
             'mojo_environment_chromium',
             'mojo_geometry_bindings',
             'mojo_geometry_lib',
-            'mojo_gles2',
-            'mojo_main_chromium',
-            'mojo_system_impl'
+            'mojo_system_impl',
+            'mojo_view_manager_bindings',
           ],
           'sources': [
+            'examples/aura_demo/context_factory_view_manager.cc',
+            'examples/aura_demo/context_factory_view_manager.h',
+            'examples/aura_demo/window_tree_host_view_manager.cc',
+            'examples/aura_demo/window_tree_host_view_manager.h',
             'examples/aura_demo/aura_demo.cc',
+            'public/cpp/application/lib/mojo_main_chromium.cc',
+          ],
+        },
+        {
+          'target_name': 'mojo_aura_demo_init',
+          'type': 'shared_library',
+          'dependencies': [
+            '../base/base.gyp:base',
+            'mojo_application',
+            'mojo_environment_chromium',
+            'mojo_system_impl',
+            'mojo_view_manager_bindings',
+          ],
+          'sources': [
+            'examples/aura_demo/view_manager_init.cc',
+            'public/cpp/application/lib/mojo_main_chromium.cc',
           ],
         },
         {