arc: Show custom notification via notification surface

ui/arc/notification/arc_notification_item.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_notification_item.h"
 
 #include <algorithm>
+#include <memory>
 #include <vector>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "components/arc/bitmap/bitmap_type_converters.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
+#include "ui/arc/notification/arc_custom_notification_view.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_types.h"
 #include "ui/message_center/notifier_settings.h"
 
 namespace arc {
 
 namespace {
 
-static const char kNotifierId[] = "ARC_NOTIFICATION";
+constexpr char kNotifierId[] = "ARC_NOTIFICATION";
+constexpr char kNotificationIdPrefix[] = "ARC_NOTIFICATION_";
 
-static const char kNotificationIdPrefix[] = "ARC_NOTIFICATION_";
+// Whether to use notification surface.
+constexpr bool use_notification_surface = true;
 
 SkBitmap DecodeImage(const std::vector<uint8_t>& data) {
   DCHECK(base::WorkerPool::RunsTasksOnCurrentThread());
   DCHECK(!data.empty());  // empty string should be handled in caller.
 
   // We may decode an image in the browser process since it has been generated
   // in NotificationListerService in Android and should be safe.
   SkBitmap bitmap;
   gfx::PNGCodec::Decode(&data[0], data.size(), &bitmap);
   return bitmap;
@@ skipping 83 matching lines @@
   void Click() override {
     if (item_)
       item_->Click();
   }
 
   void ButtonClick(int button_index) override {
     if (item_)
       item_->ButtonClick(button_index);
   }
 
+  std::unique_ptr<views::View> CreateCustomContent() override {
+    if (!item_ || !surface_)
+      return std::unique_ptr<views::View>();
+
+    return base::WrapUnique(new ArcCustomNotificationView(surface_));
+  }
+
+  void set_notification_surface(exo::NotificationSurface* surface) {
+    surface_ = surface;
+  }
+
  private:
   // The destructor is private since this class is ref-counted.
   ~ArcNotificationDelegate() override {}
 
   base::WeakPtr<ArcNotificationItem> item_;
+  exo::NotificationSurface* surface_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ArcNotificationDelegate);
 };
 
 }  // anonymous namespace
 
 ArcNotificationItem::ArcNotificationItem(
     ArcNotificationManager* manager,
     message_center::MessageCenter* message_center,
     const std::string& notification_key,
@@ skipping 85 matching lines @@
   rich_data.pinned = (data.no_clear || data.ongoing_event);
 
   rich_data.priority = convertAndroidPriority(data.priority);
 
   // The identifier of the notifier, which is used to distinguish the notifiers
   // in the message center.
   message_center::NotifierId notifier_id(
       message_center::NotifierId::SYSTEM_COMPONENT, kNotifierId);
   notifier_id.profile_id = profile_id_.GetUserEmail();
 
+  if (use_notification_surface)
+    type = message_center::NOTIFICATION_TYPE_CUSTOM;
+
   DCHECK(!data.title.is_null());
   DCHECK(!data.message.is_null());
   notification_.reset(new message_center::Notification(
       type, notification_id_, base::UTF8ToUTF16(data.title.get()),
       base::UTF8ToUTF16(data.message.get()),
       gfx::Image(),              // icon image: Will be overriden later.
       base::UTF8ToUTF16("arc"),  // display source
       GURL(),                    // empty origin url, for system component
       notifier_id, rich_data,
       new ArcNotificationDelegate(weak_ptr_factory_.GetWeakPtr())));
 
+  if (use_notification_surface) {
+    ArcNotificationSurfaceCollection* surface_collection =
+        manager_->notification_surface_collection();
+    exo::NotificationSurface* surface =
+        surface_collection->GetSurface(notification_id_);
+    if (surface)
+      OnNotificationSurfaceAdded(surface);
+    else
+      surface_collection->AddObserver(this);
+    return;

[yoshiki, 2016/06/15 11:47:20]

Please call AddToMessageCenter(). At least, we need to process |newer_data_|.

[xiyuan, 2016/06/15 19:32:44]

AddToMessageCenter() is called once the surface is available. The call is
deferred because there is nothing to show before surface is created.

[yoshiki, 2016/06/16 02:44:50]

I got it. Thank you for explanation.

+  }
+
   DCHECK(!data.icon_data.is_null());
   if (data.icon_data.size() == 0) {
     OnImageDecoded(SkBitmap());  // Pass an empty bitmap.
     return;
   }
 
   // TODO(yoshiki): Remove decoding by passing a bitmap directly from Android.
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
       base::Bind(&DecodeImage, data.icon_data.storage()),
       base::Bind(&ArcNotificationItem::OnImageDecoded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-ArcNotificationItem::~ArcNotificationItem() {}
+ArcNotificationItem::~ArcNotificationItem() {
+  manager_->notification_surface_collection()->RemoveObserver(this);
+}
 
 void ArcNotificationItem::OnClosedFromAndroid(bool by_user) {
   being_removed_by_manager_ = true;  // Closing is initiated by the manager.
   message_center_->RemoveNotification(notification_id_, by_user);
 }
 
 void ArcNotificationItem::Close(bool by_user) {
   if (being_removed_by_manager_) {
     // Closing is caused by the manager, so we don't need to nofify a close
     // event to the manager.
     return;
   }
 
   // Do not touch its any members afterwards, because this instance will be
   // destroyed in the following call
   manager_->SendNotificationRemovedFromChrome(notification_key_);
 }
 
 void ArcNotificationItem::Click() {
   manager_->SendNotificationClickedOnChrome(notification_key_);
 }
 
 void ArcNotificationItem::ButtonClick(int button_index) {
   manager_->SendNotificationButtonClickedOnChrome(
       notification_key_, button_index);
 }
 
+void ArcNotificationItem::OnNotificationSurfaceAdded(
+    exo::NotificationSurface* surface) {
+  if (!notification_ || surface->notification_id() != notification_key_)
+    return;

[yoshiki, 2016/06/15 11:47:20]

Ditto for calling AddTestMessageCenter().

[xiyuan, 2016/06/15 19:32:44]

AddToMessageCenter() is called at the end. The condition above basically says:
if there is not pending |notification_| to add, or the created surface is not
ours. And we should not AddToMessageCenter() when that is true.

+
+  static_cast<ArcNotificationDelegate*>(notification_->delegate())
+      ->set_notification_surface(surface);
+  AddToMessageCenter();
+}
+
 void ArcNotificationItem::OnImageDecoded(const SkBitmap& bitmap) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   gfx::Image image = gfx::Image::CreateFrom1xBitmap(bitmap);
   notification_->set_icon(image);
+  AddToMessageCenter();
+}
 
+void ArcNotificationItem::AddToMessageCenter() {
   DCHECK(notification_);
   message_center_->AddNotification(std::move(notification_));
 
   if (newer_data_) {
     // There is the newer data, so updates again.
     mojom::ArcNotificationDataPtr data(std::move(newer_data_));
     UpdateWithArcNotificationData(*data);
   }
 }
 
 }  // namespace arc