Gets aura_demo working with the view_manager

mojo/examples/aura_demo/context_factory_view_manager.cc

Index: mojo/examples/aura_demo/context_factory_view_manager.cc
diff --git a/mojo/examples/aura_demo/context_factory_view_manager.cc b/mojo/examples/aura_demo/context_factory_view_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..46596c333450f0658392a5b407526524c6b592d8
--- /dev/null
+++ b/mojo/examples/aura_demo/context_factory_view_manager.cc
@@ -0,0 +1,194 @@
+// 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