Merge "arc: Defer notification surface creation"

ui/arc/notification/arc_custom_notification_view.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 "ui/arc/notification/arc_custom_notification_view.h"
 
 #include "base/auto_reset.h"
 #include "components/exo/notification_surface.h"
 #include "components/exo/surface.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_handler.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/transform.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 
@@ skipping 108 matching lines @@
   void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq) override {}
 
   ArcCustomNotificationView* const owner_;
   bool sliding_ = false;
   std::unique_ptr<ui::LayerTreeOwner> surface_copy_;
 
   DISALLOW_COPY_AND_ASSIGN(SlideHelper);
 };
 
 ArcCustomNotificationView::ArcCustomNotificationView(
-    ArcCustomNotificationItem* item,
-    exo::NotificationSurface* surface)
-    : item_(item), event_forwarder_(new EventForwarder(this)) {
-  SetSurface(surface);
+    ArcCustomNotificationItem* item)
+    : item_(item),
+      notification_key_(item->notification_key()),
+      event_forwarder_(new EventForwarder(this)) {
+  item_->IncrementWindowRefCount();
   item_->AddObserver(this);
-  OnItemPinnedChanged();
+
+  ArcNotificationSurfaceManager::Get()->AddObserver(this);
+  exo::NotificationSurface* surface =
+      ArcNotificationSurfaceManager::Get()->GetSurface(notification_key_);
+  if (surface)
+    OnNotificationSurfaceAdded(surface);
 
   // Create a layer as an anchor to insert surface copy during a slide.
   SetPaintToLayer(true);
+  UpdatePreferredSize();
 }
 
 ArcCustomNotificationView::~ArcCustomNotificationView() {
   SetSurface(nullptr);
-  if (item_)
+  if (item_) {
+    item_->DecrementWindowRefCount();
     item_->RemoveObserver(this);
+  }
+
+  if (ArcNotificationSurfaceManager::Get())
+    ArcNotificationSurfaceManager::Get()->RemoveObserver(this);
 }
 
 void ArcCustomNotificationView::CreateFloatingCloseButton() {
+  if (!surface_)
+    return;
+
   floating_close_button_ = new views::ImageButton(this);
   floating_close_button_->set_background(
       views::Background::CreateSolidBackground(SK_ColorTRANSPARENT));
 
   // The sizes below are in DIPs.
   constexpr int kPaddingFromBorder = 4;
   constexpr int kImageSize = 16;
   constexpr int kTouchExtendedPadding =
       message_center::kControlButtonSize - kImageSize - kPaddingFromBorder;
   floating_close_button_->SetBorder(views::Border::CreateEmptyBorder(
@@ skipping 27 matching lines @@
   if (surface_ && surface_->window()) {
     surface_->window()->RemoveObserver(this);
     surface_->window()->RemovePreTargetHandler(event_forwarder_.get());
   }
 
   surface_ = surface;
 
   if (surface_ && surface_->window()) {
     surface_->window()->AddObserver(this);
     surface_->window()->AddPreTargetHandler(event_forwarder_.get());
+
+    if (GetWidget())
+      AttachSurface();
+
+    UpdatePinnedState();
   }
 }
 
 void ArcCustomNotificationView::UpdatePreferredSize() {
-  gfx::Size preferred_size = surface_->GetSize();
+  gfx::Size preferred_size =
+      surface_ ? surface_->GetSize() : item_ ? item_->snapshot().size()
+                                             : gfx::Size();
+  if (preferred_size.IsEmpty())
+    return;
+
   if (preferred_size.width() != message_center::kNotificationWidth) {
     const float scale = static_cast<float>(message_center::kNotificationWidth) /
                         preferred_size.width();
     preferred_size.SetSize(message_center::kNotificationWidth,
                            preferred_size.height() * scale);
   }
 
   SetPreferredSize(preferred_size);
 }
 
 void ArcCustomNotificationView::UpdateCloseButtonVisiblity() {
   if (!surface_ || !floating_close_button_widget_)
     return;
 
   const bool target_visiblity =
       surface_->window()->GetBoundsInScreen().Contains(
           display::Screen::GetScreen()->GetCursorScreenPoint());
   if (target_visiblity == floating_close_button_widget_->IsVisible())
     return;
 
   if (target_visiblity)
     floating_close_button_widget_->Show();
   else
     floating_close_button_widget_->Hide();
 }
 
+void ArcCustomNotificationView::UpdatePinnedState() {
+  if (item_->pinned() && floating_close_button_widget_) {
+    floating_close_button_widget_.reset();
+  } else if (!item_->pinned() && !floating_close_button_widget_) {
+    CreateFloatingCloseButton();
+  }
+}
+
+void ArcCustomNotificationView::UpdateSnapshot() {
+  // Bail if we have a |surface_| because it controls the sizes and paints UI.
+  if (surface_)
+    return;
+
+  UpdatePreferredSize();
+  SchedulePaint();
+}
+
+void ArcCustomNotificationView::AttachSurface() {
+  if (!GetWidget())
+    return;
+
+  UpdatePreferredSize();
+  Attach(surface_->window());
+
+  // Creates slide helper after this view is added to its parent.
+  slide_helper_.reset(new SlideHelper(this));
+}
+
 void ArcCustomNotificationView::ViewHierarchyChanged(
     const views::View::ViewHierarchyChangedDetails& details) {
   views::Widget* widget = GetWidget();
 
   if (!details.is_add) {
     // Resets slide helper when this view is removed from its parent.
     slide_helper_.reset();
   }
 
   // Bail if native_view() has attached to a different widget.
   if (widget && native_view() &&
       views::Widget::GetTopLevelWidgetForNativeView(native_view()) != widget) {
     return;
   }
 
   views::NativeViewHost::ViewHierarchyChanged(details);
 
   if (!widget || !surface_ || !details.is_add)
     return;
 
-  UpdatePreferredSize();
-  Attach(surface_->window());
-
-  // Creates slide helper after this view is added to its parent.
-  slide_helper_.reset(new SlideHelper(this));
+  AttachSurface();
 }
 
 void ArcCustomNotificationView::Layout() {
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   views::NativeViewHost::Layout();
 
   if (!surface_ || !GetWidget())
     return;
 
@@ skipping 18 matching lines @@
 
   gfx::Rect close_button_bounds(floating_close_button_->GetPreferredSize());
   close_button_bounds.set_x(contents_bounds.right() -
                             close_button_bounds.width());
   close_button_bounds.set_y(contents_bounds.y());
   floating_close_button_widget_->SetBounds(close_button_bounds);
 
   UpdateCloseButtonVisiblity();
 }
 
+void ArcCustomNotificationView::OnPaint(gfx::Canvas* canvas) {
+  views::NativeViewHost::OnPaint(canvas);
+
+  // Bail if there is a |surface_| or no item or no snapshot image.
+  if (surface_ || !item_ || item_->snapshot().isNull())
+    return;
+  const gfx::Rect contents_bounds = GetContentsBounds();
+  canvas->DrawImageInt(item_->snapshot(), 0, 0, item_->snapshot().width(),
+                       item_->snapshot().height(), contents_bounds.x(),
+                       contents_bounds.y(), contents_bounds.width(),
+                       contents_bounds.height(), false);
+}
+
 void ArcCustomNotificationView::OnKeyEvent(ui::KeyEvent* event) {
   // Forward to parent CustomNotificationView to handle keyboard dismissal.
   parent()->OnKeyEvent(event);
 }
 
 void ArcCustomNotificationView::OnGestureEvent(ui::GestureEvent* event) {
   // Forward to parent CustomNotificationView to handle sliding out.
   parent()->OnGestureEvent(event);
   slide_helper_->Update();
 }
@@ skipping 18 matching lines @@
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   if (in_layout_)
     return;
 
   UpdatePreferredSize();
   Layout();
 }
 
 void ArcCustomNotificationView::OnWindowDestroying(aura::Window* window) {
-  window->RemoveObserver(this);
+  SetSurface(nullptr);
 }
 
 void ArcCustomNotificationView::OnItemDestroying() {
   item_->RemoveObserver(this);
   item_ = nullptr;
 
   // Reset |surface_| with |item_| since no one is observing the |surface_|
   // after |item_| is gone and this view should be removed soon.
   SetSurface(nullptr);
 }
 
-void ArcCustomNotificationView::OnItemPinnedChanged() {
-  if (item_->pinned() && floating_close_button_widget_) {
-    floating_close_button_widget_.reset();
-  } else if (!item_->pinned() && !floating_close_button_widget_) {
-    CreateFloatingCloseButton();
-  }
+void ArcCustomNotificationView::OnItemUpdated() {
+  UpdatePinnedState();
+  UpdateSnapshot();
 }
 
-void ArcCustomNotificationView::OnItemNotificationSurfaceRemoved() {
+void ArcCustomNotificationView::OnNotificationSurfaceAdded(
+    exo::NotificationSurface* surface) {
+  if (surface->notification_id() != notification_key_)
+    return;
+
+  SetSurface(surface);
+}
+
+void ArcCustomNotificationView::OnNotificationSurfaceRemoved(
+    exo::NotificationSurface* surface) {
+  if (surface->notification_id() != notification_key_)
+    return;
+
   SetSurface(nullptr);
 }
 
 }  // namespace arc