[Chromecast] Support software rendering when disable-gpu used

ui/ozone/platform/cast/surface_factory_cast.cc

 // Copyright 2015 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 "ui/ozone/platform/cast/surface_factory_cast.h"
 
 #include <dlfcn.h>
 #include <EGL/egl.h>
 
 #include "base/callback_helpers.h"
 #include "chromecast/public/cast_egl_platform.h"
 #include "chromecast/public/graphics_types.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/geometry/quad_f.h"
+#include "ui/gfx/vsync_provider.h"
 #include "ui/ozone/platform/cast/surface_ozone_egl_cast.h"
 #include "ui/ozone/public/native_pixmap.h"
+#include "ui/ozone/public/surface_ozone_canvas.h"
 
 using chromecast::CastEglPlatform;
 
 namespace ui {
 
 namespace {
 
 typedef EGLDisplay (*EGLGetDisplayFn)(NativeDisplayType);
 typedef EGLBoolean (*EGLTerminateFn)(EGLDisplay);
 
 chromecast::Size FromGfxSize(const gfx::Size& size) {
   return chromecast::Size(size.width(), size.height());
 }
 
 // Initial display size to create, needed before first window is created.
 gfx::Size GetInitialDisplaySize() {
   return gfx::Size(1280, 720);
 }
 
 // Hard lower bound on display resolution
 gfx::Size GetMinDisplaySize() {
   return gfx::Size(1280, 720);
 }
 
+class DummySurface : public SurfaceOzoneCanvas {
+ public:
+  DummySurface() {}
+  ~DummySurface() override {}
+
+  // SurfaceOzoneCanvas implementation:
+  skia::RefPtr<SkSurface> GetSurface() override { return surface_; }
+
+  void ResizeCanvas(const gfx::Size& viewport_size) override {
+    surface_ = skia::AdoptRef(SkSurface::NewRaster(SkImageInfo::MakeN32Premul(
+        viewport_size.width(), viewport_size.height())));
+  }
+
+  void PresentCanvas(const gfx::Rect& damage) override {}
+
+  scoped_ptr<gfx::VSyncProvider> CreateVSyncProvider() override {
+    return nullptr;
+  }
+
+ private:
+  skia::RefPtr<SkSurface> surface_;
+
+  DISALLOW_COPY_AND_ASSIGN(DummySurface);
+};
+
 }  // namespace
 
+SurfaceFactoryCast::SurfaceFactoryCast() : SurfaceFactoryCast(nullptr) {}
+
 SurfaceFactoryCast::SurfaceFactoryCast(scoped_ptr<CastEglPlatform> egl_platform)
     : state_(kUninitialized),
       display_type_(0),
       have_display_type_(false),
       window_(0),
       display_size_(GetInitialDisplaySize()),
       new_display_size_(GetInitialDisplaySize()),
       egl_platform_(egl_platform.Pass()) {
 }
 
@@ skipping 38 matching lines @@
   if (state_ != kInitialized)
     return;
 
   DestroyDisplayTypeAndWindow();
 
   egl_platform_->ShutdownHardware();
 
   state_ = kUninitialized;
 }
 
+scoped_ptr<SurfaceOzoneCanvas> SurfaceFactoryCast::CreateCanvasForWidget(
+    gfx::AcceleratedWidget widget) {
+  // Software canvas support only in headless mode
+  if (egl_platform_)
+    return nullptr;
+  return make_scoped_ptr<SurfaceOzoneCanvas>(new DummySurface());
+}
+
 intptr_t SurfaceFactoryCast::GetNativeDisplay() {
   CreateDisplayTypeAndWindowIfNeeded();
   return reinterpret_cast<intptr_t>(display_type_);
 }
 
 void SurfaceFactoryCast::CreateDisplayTypeAndWindowIfNeeded() {
   if (state_ == kUninitialized) {
     InitializeHardware();
   }
   if (new_display_size_ != display_size_) {
@@ skipping 60 matching lines @@
   if (egl_platform_->MultipleSurfaceUnsupported())
     DestroyWindow();
 }
 
 const int32* SurfaceFactoryCast::GetEGLSurfaceProperties(
     const int32* desired_list) {
   return egl_platform_->GetEGLSurfaceProperties(desired_list);
 }
 
 scoped_refptr<NativePixmap> SurfaceFactoryCast::CreateNativePixmap(
-    gfx::AcceleratedWidget w,
+    gfx::AcceleratedWidget widget,
     gfx::Size size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
   class CastPixmap : public NativePixmap {
    public:
     CastPixmap() {}
 
     void* GetEGLClientBuffer() const override {
       // TODO(halliwell): try to implement this through CastEglPlatform.
       return nullptr;
@@ skipping 48 matching lines @@
     return false;
   }
 
   set_gl_get_proc_address.Run(gl_proc);
   add_gl_library.Run(lib_egl);
   add_gl_library.Run(lib_gles2);
   return true;
 }
 
 }  // namespace ui