Loads CastEglPlatform implementation from shared library.

chromecast/ozone/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 "chromecast/ozone/surface_factory_cast.h"
 
 #include "base/callback_helpers.h"
-#include "chromecast/ozone/cast_egl_platform.h"
 #include "chromecast/ozone/surface_ozone_egl_cast.h"
+#include "chromecast/public/cast_egl_platform.h"
 
 namespace chromecast {
 namespace ozone {
+namespace {
+CastEglPlatform::Size FromGfxSize(const gfx::Size& size) {
+  return CastEglPlatform::Size(size.width(), size.height());
+}
+gfx::Size ToGfxSize(const CastEglPlatform::Size& size) {
+  return gfx::Size(size.width_, size.height_);
+}
+}
 
 SurfaceFactoryCast::SurfaceFactoryCast(scoped_ptr<CastEglPlatform> egl_platform)
     : state_(kUninitialized),
       destroy_window_pending_state_(kNoDestroyPending),
       display_type_(0),
       window_(0),
-      default_display_size_(egl_platform->GetDefaultDisplaySize()),
+      default_display_size_(ToGfxSize(egl_platform->GetDefaultDisplaySize())),
       display_size_(default_display_size_),
       new_display_size_(default_display_size_),
       egl_platform_(egl_platform.Pass()) {
 }
 
 SurfaceFactoryCast::~SurfaceFactoryCast() {
   DestroyDisplayTypeAndWindow();
 }
 
 void SurfaceFactoryCast::InitializeHardware() {
@@ skipping 26 matching lines @@
 void SurfaceFactoryCast::CreateDisplayTypeAndWindowIfNeeded() {
   if (state_ == kUninitialized) {
     InitializeHardware();
   }
   if (new_display_size_ != display_size_) {
     DestroyDisplayTypeAndWindow();
     display_size_ = new_display_size_;
   }
   DCHECK_EQ(state_, kInitialized);
   if (!display_type_) {
-    display_type_ = egl_platform_->CreateDisplayType(display_size_);
+    CastEglPlatform::Size create_size = FromGfxSize(display_size_);
+    display_type_ = egl_platform_->CreateDisplayType(create_size);
     if (display_type_) {
-      window_ = egl_platform_->CreateWindow(display_type_, display_size_);
+      window_ = egl_platform_->CreateWindow(display_type_, create_size);
       if (!window_) {
         DestroyDisplayTypeAndWindow();
         state_ = kFailed;
         LOG(FATAL) << "Create EGLNativeWindowType(" << display_size_.ToString()
                    << ") failed.";
       }
     } else {
       state_ = kFailed;
       LOG(FATAL) << "Create EGLNativeDisplayType(" << display_size_.ToString()
                  << ") failed.";
@@ skipping 82 matching lines @@
 bool SurfaceFactoryCast::LoadEGLGLES2Bindings(
     AddGLLibraryCallback add_gl_library,
     SetGLGetProcAddressProcCallback set_gl_get_proc_address) {
   if (state_ != kInitialized) {
     InitializeHardware();
     if (state_ != kInitialized) {
       return false;
     }
   }
 
-  return egl_platform_->LoadEGLGLES2Bindings(add_gl_library,
-                                             set_gl_get_proc_address);
+  void* lib_egl = egl_platform_->GetEglLibrary();
+  void* lib_gles2 = egl_platform_->GetGles2Library();
+  GLGetProcAddressProc gl_proc = egl_platform_->GetGLProcAddressProc();
+  if (!lib_egl || !lib_gles2 || !gl_proc) {
+    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 ozone
 }  // namespace chromecast