[Chromecast] Set Cast Ozone display size correctly first time

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 <EGL/egl.h>
 #include <dlfcn.h>
 
 #include <utility>
 
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "chromecast/base/chromecast_switches.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() {
+// Display resolution, set in browser process and passed by switches.
+gfx::Size GetDisplaySize() {
+  base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  int width, height;
+  if (base::StringToInt(
+          cmd_line->GetSwitchValueASCII(switches::kCastInitialScreenWidth),
+          &width) &&
+      base::StringToInt(
+          cmd_line->GetSwitchValueASCII(switches::kCastInitialScreenHeight),
+          &height)) {
+    return gfx::Size(width, height);
+  }
+  LOG(WARNING) << "Unable to get initial screen resolution from command line,"
+               << "using default 720p";
   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:
   sk_sp<SkSurface> GetSurface() override { return surface_; }
 
   void ResizeCanvas(const gfx::Size& viewport_size) override {
     surface_ = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(
@@ skipping 15 matching lines @@
 }  // namespace
 
 SurfaceFactoryCast::SurfaceFactoryCast() : SurfaceFactoryCast(nullptr) {}
 
 SurfaceFactoryCast::SurfaceFactoryCast(
     std::unique_ptr<CastEglPlatform> egl_platform)
     : state_(kUninitialized),
       display_type_(0),
       have_display_type_(false),
       window_(0),
-      display_size_(GetInitialDisplaySize()),
-      new_display_size_(GetInitialDisplaySize()),
+      display_size_(GetDisplaySize()),
       egl_platform_(std::move(egl_platform)),
       overlay_count_(0),
       previous_frame_overlay_count_(0) {}
 
 SurfaceFactoryCast::~SurfaceFactoryCast() {
   ShutdownHardware();
 }
 
 void SurfaceFactoryCast::InitializeHardware() {
   if (state_ == kInitialized) {
@@ skipping 74 matching lines @@
 
 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_) {
-    DestroyDisplayTypeAndWindow();
-    display_size_ = new_display_size_;
-  }
   DCHECK_EQ(state_, kInitialized);
   if (!have_display_type_) {
     chromecast::Size create_size = FromGfxSize(display_size_);
     display_type_ = egl_platform_->CreateDisplayType(create_size);
     have_display_type_ = true;
   }
   if (!window_) {
     chromecast::Size create_size = FromGfxSize(display_size_);
     window_ = egl_platform_->CreateWindow(display_type_, create_size);
     if (!window_) {
       DestroyDisplayTypeAndWindow();
       state_ = kFailed;
       LOG(FATAL) << "Create EGLNativeWindowType(" << display_size_.ToString()
                  << ") failed.";
     }
   }
 }
 
 intptr_t SurfaceFactoryCast::GetNativeWindow() {
   CreateDisplayTypeAndWindowIfNeeded();
   return reinterpret_cast<intptr_t>(window_);
 }
 
 bool SurfaceFactoryCast::ResizeDisplay(gfx::Size size) {
-  // set size to at least 1280x720 even if passed 1x1
-  size.SetToMax(GetMinDisplaySize());
-  if (have_display_type_ && size != display_size_) {
-    DestroyDisplayTypeAndWindow();
-  }
-  display_size_ = size;
+  DCHECK_EQ(size.width(), display_size_.width());
+  DCHECK_EQ(size.height(), display_size_.height());
   return true;
 }
 
 void SurfaceFactoryCast::DestroyWindow() {
   if (window_) {
     egl_platform_->DestroyWindow(window_);
     window_ = 0;
   }
 }
 
 void SurfaceFactoryCast::DestroyDisplayTypeAndWindow() {
   DestroyWindow();
   if (have_display_type_) {
     egl_platform_->DestroyDisplayType(display_type_);
     display_type_ = 0;
     have_display_type_ = false;
   }
 }
 
 std::unique_ptr<SurfaceOzoneEGL> SurfaceFactoryCast::CreateEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
-  new_display_size_ = gfx::Size(widget >> 16, widget & 0xFFFF);
-  new_display_size_.SetToMax(GetMinDisplaySize());
+  // Verify requested widget dimensions match our current display size.
+  DCHECK_EQ(widget >> 16, display_size_.width());
+  DCHECK_EQ(widget & 0xffff, display_size_.height());
   return base::WrapUnique<SurfaceOzoneEGL>(new SurfaceOzoneEglCast(this));
 }
 
 void SurfaceFactoryCast::ChildDestroyed() {
   if (egl_platform_->MultipleSurfaceUnsupported())
     DestroyWindow();
 }
 
 scoped_refptr<NativePixmap> SurfaceFactoryCast::CreateNativePixmap(
     gfx::AcceleratedWidget widget,
@@ skipping 59 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