| // 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/aura/context_factory_mojo.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/aura/window_tree_host_mojo.h" |
| #include "skia/ext/platform_canvas.h" |
| #include "ui/compositor/reflector.h" |
| |
| namespace mojo { |
| namespace { |
| |
| void FreeSharedBitmap(cc::SharedBitmap* shared_bitmap) { |
| delete shared_bitmap->memory(); |
| } |
| |
| void IgnoreSharedBitmap(cc::SharedBitmap* shared_bitmap) {} |
| |
| class SoftwareOutputDeviceViewManager : public cc::SoftwareOutputDevice { |
| public: |
| explicit SoftwareOutputDeviceViewManager(ui::Compositor* compositor) |
| : compositor_(compositor) { |
| } |
| virtual ~SoftwareOutputDeviceViewManager() {} |
| |
| // cc::SoftwareOutputDevice: |
| virtual void EndPaint(cc::SoftwareFrameData* frame_data) OVERRIDE { |
| WindowTreeHostMojo* window_tree_host = |
| WindowTreeHostMojo::ForCompositor(compositor_); |
| DCHECK(window_tree_host); |
| window_tree_host->SetContents( |
| skia::GetTopDevice(*canvas_)->accessBitmap(true)); |
| |
| SoftwareOutputDevice::EndPaint(frame_data); |
| } |
| |
| private: |
| ui::Compositor* compositor_; |
| |
| 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 |
| |
| ContextFactoryMojo::ContextFactoryMojo() |
| : shared_bitmap_manager_(new TestSharedBitmapManager()) { |
| } |
| |
| ContextFactoryMojo::~ContextFactoryMojo() {} |
| |
| scoped_ptr<cc::OutputSurface> ContextFactoryMojo::CreateOutputSurface( |
| ui::Compositor* compositor, |
| bool software_fallback) { |
| scoped_ptr<cc::SoftwareOutputDevice> output_device( |
| new SoftwareOutputDeviceViewManager(compositor)); |
| return make_scoped_ptr(new cc::OutputSurface(output_device.Pass())); |
| } |
| |
| scoped_refptr<ui::Reflector> ContextFactoryMojo::CreateReflector( |
| ui::Compositor* mirroed_compositor, |
| ui::Layer* mirroring_layer) { |
| return new ui::Reflector(); |
| } |
| |
| void ContextFactoryMojo::RemoveReflector( |
| scoped_refptr<ui::Reflector> reflector) { |
| } |
| |
| scoped_refptr<cc::ContextProvider> |
| ContextFactoryMojo::SharedMainThreadContextProvider() { |
| return scoped_refptr<cc::ContextProvider>(NULL); |
| } |
| |
| void ContextFactoryMojo::RemoveCompositor(ui::Compositor* compositor) {} |
| |
| bool ContextFactoryMojo::DoesCreateTestContexts() { return false; } |
| |
| cc::SharedBitmapManager* ContextFactoryMojo::GetSharedBitmapManager() { |
| return shared_bitmap_manager_.get(); |
| } |
| |
| base::MessageLoopProxy* ContextFactoryMojo::GetCompositorMessageLoop() { |
| return NULL; |
| } |
| |
| } // namespace mojo |