Mus Demo: Code cleanup in MusDemo::WindowTreeData

services/ui/demo/mus_demo.cc

 // Copyright 2016 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 "services/ui/demo/mus_demo.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service_context.h"
@@ skipping 55 matching lines @@
 }
 
 }  // namespace
 
 class MusDemo::WindowTreeData {
  public:
   explicit WindowTreeData(
       std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
     Init(std::move(window_tree_host));
   }
-  ~WindowTreeData();
 
  private:
   // Initializes the window tree host and start drawing frames.
   void Init(std::unique_ptr<aura::WindowTreeHostMus> window_tree_host);
 
   // Draws one frame, incrementing the rotation angle.
   void DrawFrame();
 
+  // Helper function to retrieve the window to which we draw the bitmap.
+  aura::Window* BitmapWindow() {

[sky, 2017/02/10 18:48:37]

GetBitmapWindow(), or as this is inlined and cheap, bitmap_window().

[fwang, 2017/02/11 09:58:48]

Done.

+    return window_tree_host_->window()->children()[0];

[sky, 2017/02/10 18:48:38]

DCHECK(!children.empty())

[fwang, 2017/02/11 09:58:48]

Done.

+  }
+
   // The Window tree host corresponding to this data.
   std::unique_ptr<aura::WindowTreeHostMus> window_tree_host_;
 
-  // Root window of the window tree host.
-  aura::Window* root_window_ = nullptr;
-
-  // Window to which we draw the bitmap.
-  std::unique_ptr<aura::Window> bitmap_window_;
-
   // Destroys itself when the window gets destroyed.
   aura_extra::ImageWindowDelegate* window_delegate_ = nullptr;
 
   // Timer for calling DrawFrame().
   base::RepeatingTimer timer_;
 
   // Current rotation angle for drawing.
   double angle_ = 0.0;
-
-  // Last time a frame was drawn.
-  base::TimeTicks last_draw_frame_time_;
 };

[sky, 2017/02/10 18:48:38]

DISALLOW...

[fwang, 2017/02/11 09:58:48]

Done.

 
-MusDemo::WindowTreeData::~WindowTreeData() {
-  timer_.Stop();
-  root_window_->RemoveChild(bitmap_window_.get());
-  bitmap_window_.reset();
-}
-
 void MusDemo::WindowTreeData::Init(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   window_tree_host->InitHost();
   window_tree_host->Show();
-  root_window_ = window_tree_host->window();
   // Take ownership of the WTH.
   window_tree_host_ = std::move(window_tree_host);
 
   // Initialize the window for the bitmap.
   window_delegate_ = new aura_extra::ImageWindowDelegate();
-  bitmap_window_ = base::MakeUnique<aura::Window>(window_delegate_);
-  bitmap_window_->Init(LAYER_TEXTURED);
-  bitmap_window_->SetBounds(root_window_->bounds());
-  bitmap_window_->Show();
-  bitmap_window_->SetName("Bitmap");
-
-  root_window_->AddChild(bitmap_window_.get());
+  aura::Window* root_window = window_tree_host_->window();
+  aura::Window* bitmap_window = new aura::Window(window_delegate_);
+  bitmap_window->Init(LAYER_TEXTURED);
+  bitmap_window->SetBounds(root_window->bounds());

[sky, 2017/02/10 18:48:38]

bitmap_window should have the same size, but an origin of 0x0, e.g.
gfx::Rect(root_window->bounds().size());

[fwang, 2017/02/11 09:58:48]

Done.

+  bitmap_window->Show();
+  bitmap_window->SetName("Bitmap");
+  root_window->AddChild(bitmap_window);
 
   // Draw initial frame and start the timer to regularly draw frames.
   DrawFrame();
   timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(kFrameDelay),
                base::Bind(&WindowTreeData::DrawFrame, base::Unretained(this)));
 }
 
 MusDemo::MusDemo() {}
 
 MusDemo::~MusDemo() {
@@ skipping 110 matching lines @@
 void MusDemo::OnWmSetClientArea(
     aura::Window* window,
     const gfx::Insets& insets,
     const std::vector<gfx::Rect>& additional_client_areas) {}
 
 bool MusDemo::IsWindowActive(aura::Window* window) { return false; }
 
 void MusDemo::OnWmDeactivateWindow(aura::Window* window) {}
 
 void MusDemo::WindowTreeData::DrawFrame() {
-  base::TimeTicks now = base::TimeTicks::Now();
-
-  VLOG(1) << (now - last_draw_frame_time_).InMilliseconds()
-          << "ms since the last frame was drawn.";
-  last_draw_frame_time_ = now;
-
   angle_ += 2.0;
   if (angle_ >= 360.0)
     angle_ = 0.0;
 
-  const gfx::Rect& bounds = bitmap_window_->bounds();
+  const gfx::Rect& bounds = BitmapWindow()->bounds();
 
   // Allocate a bitmap of correct size.
   SkBitmap bitmap;
   SkImageInfo image_info = SkImageInfo::MakeN32(bounds.width(), bounds.height(),
                                                 kPremul_SkAlphaType);
   bitmap.allocPixels(image_info);
 
   // Draw the rotated square on background in bitmap.
   SkCanvas canvas(bitmap);
   canvas.clear(kBgColor);
   // TODO(kylechar): Add GL drawing instead of software rasterization in future.
   DrawSquare(bounds, angle_, &canvas);
   canvas.flush();
 
   gfx::ImageSkiaRep image_skia_rep(bitmap, 1);
   gfx::ImageSkia image_skia(image_skia_rep);
   gfx::Image image(image_skia);
 
   window_delegate_->SetImage(image);
-  bitmap_window_->SchedulePaintInRect(bitmap_window_->bounds());
+  BitmapWindow()->SchedulePaintInRect(BitmapWindow()->bounds());

[sky, 2017/02/10 18:48:37]

SchedulePaintInRect() takes a rectangle in the coordinates of the view you are
calling paint on. You are passing the bounds of the same window. Bounds are in
the coordinates of the parent. In other words you have a coordinate system
mismatch here. It doesn't really matter in this case since you know the origin
is 0x0, but it's good practice to do the right thing in case that changes, which
is window->SchedulePaintInRect(gfx::Rect(window->bounds().size());

[fwang, 2017/02/11 09:58:48]

Done.

 }
 
 }  // namespace demo
 }  // namespace aura