WIP

components/exo/shell_surface.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 "components/exo/shell_surface.h"
 
 #include <algorithm>
 
 #include "ash/frame/custom_frame_view_ash.h"
 #include "ash/public/cpp/shell_window_ids.h"
@@ skipping 42 matching lines @@
 
 // This is a struct for accelerator keys used to close ShellSurfaces.
 const struct Accelerator {
   ui::KeyboardCode keycode;
   int modifiers;
 } kCloseWindowAccelerators[] = {
     {ui::VKEY_W, ui::EF_CONTROL_DOWN},
     {ui::VKEY_W, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN},
     {ui::VKEY_F4, ui::EF_ALT_DOWN}};
 
+constexpr uint32_t kFirstIconChunkFlag = 0x1;
+constexpr uint32_t kLastIconChunkFlag = 0x2;
+constexpr size_t kMaxIconSize = 32 * 1024;
+
 class CustomFrameView : public views::NonClientFrameView {
  public:
   explicit CustomFrameView(views::Widget* widget) : widget_(widget) {}
   ~CustomFrameView() override {}
 
   // Overridden from views::NonClientFrameView:
   gfx::Rect GetBoundsForClientView() const override { return bounds(); }
   gfx::Rect GetWindowBoundsForClientBounds(
       const gfx::Rect& client_bounds) const override {
     return client_bounds;
@@ skipping 232 matching lines @@
     DCHECK_EQ(window->GetProperty(aura::client::kAnimationsDisabledKey), true);
     window->SetProperty(aura::client::kAnimationsDisabledKey,
                         saved_animations_disabled_);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellSurface, public:
 
 DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(Surface*, kMainSurfaceKey, nullptr)
+DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(std::string*, kUnsafeIconPngDataKey, nullptr)
 
 ShellSurface::ShellSurface(Surface* surface,
                            ShellSurface* parent,
                            BoundsMode bounds_mode,
                            const gfx::Point& origin,
                            bool activatable,
                            bool can_minimize,
                            int container)
     : widget_(nullptr),
       surface_(surface),
@@ skipping 189 matching lines @@
 
 void ShellSurface::SetTitle(const base::string16& title) {
   TRACE_EVENT1("exo", "ShellSurface::SetTitle", "title",
                base::UTF16ToUTF8(title));
 
   title_ = title;
   if (widget_)
     widget_->UpdateWindowTitle();
 }
 
+void ShellSurface::SetIconChunk(uint32_t flags,
+                                const std::string& unsafe_icon_png) {
+  TRACE_EVENT0("exo", "ShellSurface::SetIconChunk");
+
+  if (flags & kFirstIconChunkFlag) {
+    unsafe_icon_png_builder_.clear();
+  } else if (unsafe_icon_png_builder_.empty()) {
+    LOG(ERROR) << "Received shelf icon chunk withot first chunk.";
+    return;
+  }
+
+  if (unsafe_icon_png.size() + unsafe_icon_png_builder_.size() > kMaxIconSize) {
+    unsafe_icon_png_builder_.clear();
+    LOG(WARNING) << "Surface icon is too big "
+                 << (unsafe_icon_png.size() + unsafe_icon_png_builder_.size())
+                 << ".";
+    return;
+  }
+
+  unsafe_icon_png_builder_ += unsafe_icon_png;
+  if (flags & kLastIconChunkFlag) {
+    unsafe_icon_png_ = unsafe_icon_png_builder_;
+    unsafe_icon_png_builder_.clear();
+    if (widget_ && widget_->GetNativeWindow())
+      SetUnsafeIconPngData(widget_->GetNativeWindow(), &unsafe_icon_png_);
+  }
+}
+
+void ShellSurface::ResetIcon() {
+  unsafe_icon_png_.clear();
+  unsafe_icon_png_builder_.clear();
+  if (widget_ && widget_->GetNativeWindow())
+    SetUnsafeIconPngData(widget_->GetNativeWindow(), nullptr);
+}
+
 void ShellSurface::SetSystemModal(bool system_modal) {
   // System modal container is used by clients to implement client side
   // managed system modal dialogs using a single ShellSurface instance.
   // Hit-test region will be non-empty when at least one dialog exists on
   // the client side. Here we detect the transition between no client side
   // dialog and at least one dialog so activatable state is properly
   // updated.
   if (container_ != ash::kShellWindowId_SystemModalContainer) {
     LOG(ERROR)
         << "Only a window in SystemModalContainer can change the modality";
@@ skipping 167 matching lines @@
 // static
 void ShellSurface::SetMainSurface(aura::Window* window, Surface* surface) {
   window->SetProperty(kMainSurfaceKey, surface);
 }
 
 // static
 Surface* ShellSurface::GetMainSurface(const aura::Window* window) {
   return window->GetProperty(kMainSurfaceKey);
 }
 
+// static
+bool ShellSurface::IsUnsafeIconPngDataKey(const void* key) {
+  return key == kUnsafeIconPngDataKey;
+}
+
+// static
+const std::string* ShellSurface::GetUnsafeIconPngData(
+    const aura::Window* window) {
+  return window->GetProperty(kUnsafeIconPngDataKey);
+}
+
+// static
+void ShellSurface::SetUnsafeIconPngData(aura::Window* window,
+                                        std::string* unsage_icon_png_data) {
+  return window->SetProperty(kUnsafeIconPngDataKey, unsage_icon_png_data);
+}
+
 std::unique_ptr<base::trace_event::TracedValue> ShellSurface::AsTracedValue()
     const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   value->SetString("title", base::UTF16ToUTF8(title_));
   std::string application_id;
   if (GetWidget() && GetWidget()->GetNativeWindow())
     application_id = GetApplicationId(GetWidget()->GetNativeWindow());
   value->SetString("application_id", application_id);
   return value;
@@ skipping 472 matching lines @@
   widget_ = new ShellSurfaceWidget(this);
   widget_->Init(params);
 
   aura::Window* window = widget_->GetNativeWindow();
   window->SetName("ExoShellSurface");
   window->SetProperty(aura::client::kAccessibilityFocusFallsbackToWidgetKey,
                       false);
   window->AddChild(surface_->window());
   window->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter(widget_)));
   SetApplicationId(window, application_id_);
+  if (!unsafe_icon_png_.empty())
+    SetUnsafeIconPngData(window, &unsafe_icon_png_);
   SetMainSurface(window, surface_);
 
   // Start tracking changes to window bounds and window state.
   window->AddObserver(this);
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
   window_state->AddObserver(this);
 
   // Allow the client to request bounds that do not fill the entire work area
   // when maximized, or the entire display when fullscreen.
   window_state->set_allow_set_bounds_direct(bounds_mode_ == BoundsMode::CLIENT);
@@ skipping 524 matching lines @@
 gfx::Point ShellSurface::GetMouseLocation() const {
   aura::Window* const root_window = widget_->GetNativeWindow()->GetRootWindow();
   gfx::Point location =
       root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
   aura::Window::ConvertPointToTarget(
       root_window, widget_->GetNativeWindow()->parent(), &location);
   return location;
 }
 
 }  // namespace exo