[Remoting Client] Always ResizeToFit when desktop/surface size is changed

remoting/client/desktop_viewport.cc

 // Copyright 2017 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 "remoting/client/desktop_viewport.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 
 namespace remoting {
 
 namespace {
 
 float MAX_ZOOM_LEVEL = 100.f;
 
 }  // namespace
 
 DesktopViewport::DesktopViewport() : desktop_to_surface_transform_() {}
 
 DesktopViewport::~DesktopViewport() {}
 
 void DesktopViewport::SetDesktopSize(int desktop_width, int desktop_height) {
-  bool need_resize_to_fit = !desktop_size_ready_ && surface_size_ready_;
   desktop_size_.x = desktop_width;
   desktop_size_.y = desktop_height;
-  desktop_size_ready_ = true;
-  if (need_resize_to_fit) {
-    ResizeToFit();
-  } else if (IsViewportReady()) {
-    UpdateViewport();
-  }
+  ResizeToFit();
 }
 
 void DesktopViewport::SetSurfaceSize(int surface_width, int surface_height) {
-  bool need_resize_to_fit = desktop_size_ready_ && !surface_size_ready_;
   surface_size_.x = surface_width;
   surface_size_.y = surface_height;
-  surface_size_ready_ = true;
-  if (need_resize_to_fit) {
-    ResizeToFit();
-  } else if (IsViewportReady()) {
-    UpdateViewport();
-  }
+  ResizeToFit();
 }
 
 void DesktopViewport::MoveDesktop(float dx, float dy) {
   desktop_to_surface_transform_.PostTranslate({dx, dy});
   UpdateViewport();
 }
 
 void DesktopViewport::ScaleDesktop(float px, float py, float scale) {
   desktop_to_surface_transform_.PostScale({px, py}, scale);
   UpdateViewport();
 }
 
 void DesktopViewport::SetViewportCenter(float x, float y) {
   ViewMatrix::Point old_center = GetViewportCenter();
   MoveViewportCenterWithoutUpdate(x - old_center.x, y - old_center.y);
   UpdateViewport();
 }
 
 void DesktopViewport::RegisterOnTransformationChangedCallback(
     const TransformationCallback& callback,
     bool run_immediately) {
   on_transformation_changed_ = callback;
   if (IsViewportReady() && run_immediately) {
     callback.Run(desktop_to_surface_transform_);
   }
 }
 
 void DesktopViewport::ResizeToFit() {
-  DCHECK(IsViewportReady());
+  if (!IsViewportReady()) {
+    return;
+  }
 
   // <---Desktop Width---->
   // +==========+---------+
   // |          |         |
   // | Viewport | Desktop |
   // |          |         |
   // +==========+---------+
   //
   // +==========+ ^
   // |          | |
   // | Viewport | |
   // |          | |
   // +==========+ | Desktop
   // |          | | Height
   // | Desktop  | |
   // |          | |
   // +----------+ v
   // resize the desktop such that it fits the viewport in one dimension.
 
   float scale = std::max(surface_size_.x / desktop_size_.x,
                          surface_size_.y / desktop_size_.y);
   desktop_to_surface_transform_.SetScale(scale);
+  desktop_to_surface_transform_.SetOffset({0.f, 0.f});
   UpdateViewport();
 }
 
 bool DesktopViewport::IsViewportReady() const {
-  return desktop_size_ready_ && surface_size_ready_;
+  return desktop_size_.x != 0 && desktop_size_.y != 0 && surface_size_.x != 0 &&
+         surface_size_.y != 0;
 }
 
 void DesktopViewport::UpdateViewport() {
   if (!IsViewportReady()) {
     // User may attempt to zoom and pan before the desktop image is received.
     // This should be fine since the viewport will be reset once the image
     // dimension is set.
     VLOG(1) << "Viewport is not ready yet.";
     return;
   }
@@ skipping 118 matching lines @@
 
   if (new_point.y < bounds.top) {
     new_point.y = bounds.top;
   } else if (new_point.y > bounds.bottom) {
     new_point.y = bounds.bottom;
   }
   return new_point;
 }
 
 }  // namespace remoting