Wires up immersive mode for chrome and mash

chrome/browser/ui/views/frame/immersive_mode_controller_ash.cc

 // Copyright 2012 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 "chrome/browser/ui/views/frame/immersive_mode_controller_ash.h"
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/shared/immersive_revealed_lock.h"
 #include "ash/shell.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/macros.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/ui/ash/ash_util.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
+#include "services/ui/public/cpp/property_type_converters.h"
+#include "services/ui/public/cpp/window_tree_client.h"
+#include "services/ui/public/interfaces/window_manager.mojom.h"
+#include "ui/aura/mus/mus_util.h"
 #include "ui/aura/window.h"
+#include "ui/compositor/paint_context.h"
+#include "ui/compositor/paint_recorder.h"
+#include "ui/views/mus/native_widget_mus.h"
+#include "ui/views/mus/window_manager_connection.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
 namespace {
 
 // Revealing the TopContainerView looks better if the animation starts and ends
 // just a few pixels before the view goes offscreen, which reduces the visual
 // "pop" as the 3-pixel tall "light bar" style tab strip becomes visible.
 const int kAnimationOffsetY = 3;
@@ skipping 17 matching lines @@
  public:
   explicit ImmersiveRevealedLockAsh(ash::ImmersiveRevealedLock* lock)
       : lock_(lock) {}
 
  private:
   std::unique_ptr<ash::ImmersiveRevealedLock> lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ImmersiveRevealedLockAsh);
 };
 
+// TODO(sky): remove this, should instead create a layer that is clone of
+// existing layers. http://crbug.com/640378.
+class DelegatingPaintView : public views::View {
+ public:
+  explicit DelegatingPaintView(views::View* view) : view_(view) {}
+
+  ~DelegatingPaintView() override {}
+
+  // views::View:
+  void PaintChildren(const ui::PaintContext& context) override {
+    view_->Paint(ui::PaintContext(
+        context, ui::PaintContext::CLONE_WITHOUT_INVALIDATION));
+  }
+
+ private:
+  views::View* view_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelegatingPaintView);
+};
+
 }  // namespace
 
 ImmersiveModeControllerAsh::ImmersiveModeControllerAsh()
     : ImmersiveModeController(Type::ASH),
       controller_(new ash::ImmersiveFullscreenController),
       browser_view_(nullptr),
-      native_window_(nullptr),
       observers_enabled_(false),
       use_tab_indicators_(false),
       visible_fraction_(1) {}
 
 ImmersiveModeControllerAsh::~ImmersiveModeControllerAsh() {
   EnableWindowObservers(false);
 }
 
 void ImmersiveModeControllerAsh::Init(BrowserView* browser_view) {
   browser_view_ = browser_view;
-  native_window_ = browser_view_->GetNativeWindow();
   controller_->Init(this, browser_view_->frame(),
       browser_view_->top_container());
 }
 
 void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
   if (controller_->IsEnabled() == enabled)
     return;
 
   EnableWindowObservers(enabled);
 
@@ skipping 48 matching lines @@
 
 void ImmersiveModeControllerAsh::EnableWindowObservers(bool enable) {
   if (observers_enabled_ == enable)
     return;
   observers_enabled_ = enable;
 
   content::Source<FullscreenController> source(browser_view_->browser()
                                                    ->exclusive_access_manager()
                                                    ->fullscreen_controller());
   if (enable) {
-    ash::wm::GetWindowState(native_window_)->AddObserver(this);
+    if (chrome::IsRunningInMash()) {
+      // TODO: http://crbug.com/640381.
+      NOTIMPLEMENTED();
+    } else {
+      ash::wm::GetWindowState(browser_view_->GetNativeWindow())
+          ->AddObserver(this);
+    }
     registrar_.Add(this, chrome::NOTIFICATION_FULLSCREEN_CHANGED, source);
   } else {
-    ash::wm::GetWindowState(native_window_)->RemoveObserver(this);
+    if (chrome::IsRunningInMash()) {
+      // TODO: http://crbug.com/640381.
+      NOTIMPLEMENTED();
+    } else {
+      ash::wm::GetWindowState(browser_view_->GetNativeWindow())
+          ->RemoveObserver(this);
+    }
     registrar_.Remove(this, chrome::NOTIFICATION_FULLSCREEN_CHANGED, source);
   }
 }
 
 void ImmersiveModeControllerAsh::LayoutBrowserRootView() {
   views::Widget* widget = browser_view_->frame();
   // Update the window caption buttons.
   widget->non_client_view()->frame_view()->ResetWindowControls();
   widget->non_client_view()->frame_view()->InvalidateLayout();
   browser_view_->InvalidateLayout();
@@ skipping 19 matching lines @@
   }
 
   bool show_tab_indicators = use_tab_indicators_ && !IsRevealed();
   if (show_tab_indicators != browser_view_->tabstrip()->IsImmersiveStyle()) {
     browser_view_->tabstrip()->SetImmersiveStyle(show_tab_indicators);
     return true;
   }
   return false;
 }
 
+void ImmersiveModeControllerAsh::CreateMashRevealWidget() {
+  if (!chrome::IsRunningInMash())
+    return;
+
+  DCHECK(!mash_reveal_widget_);
+  mash_reveal_widget_.reset(new views::Widget);
+  views::Widget::InitParams init_params(views::Widget::InitParams::TYPE_POPUP);
+  std::map<std::string, std::vector<uint8_t>> window_properties;
+  window_properties
+      [ui::mojom::WindowManager::kRendererParentTitleArea_Property] =

[James Cook, 2016/08/24 17:00:32]

optional: "using ui::mojom::WindowManager;" might make this wrap better

[sky, 2016/08/24 19:23:29]

That doesn't work for constants.

+          mojo::ConvertTo<std::vector<uint8_t>>(true);
+  window_properties[ui::mojom::WindowManager::kName_Property] =
+      mojo::ConvertTo<std::vector<uint8_t>>(
+          std::string("ChromeImmersiveRevealWindow"));

[James Cook, 2016/08/24 17:00:32]

I think you can just set init_params.name for this.

[sky, 2016/08/24 19:23:29]

That only works if WindowManagerConnection creates the window, because the
window is not created through WindowManagerConnection it won't work.

+  init_params.native_widget = new views::NativeWidgetMus(
+      mash_reveal_widget_.get(),
+      views::WindowManagerConnection::Get()->client()->NewWindow(
+          &window_properties),
+      ui::mojom::SurfaceType::DEFAULT);
+  init_params.accept_events = false;
+  init_params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  init_params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
+  init_params.parent_mus = GetMusWindow(browser_view_->GetNativeWindow());
+  const gfx::Rect& top_container_bounds =
+      browser_view_->top_container()->bounds();
+  init_params.bounds =
+      gfx::Rect(0, -top_container_bounds.height(), top_container_bounds.width(),
+                top_container_bounds.height());
+  mash_reveal_widget_->Init(init_params);
+  mash_reveal_widget_->SetContentsView(
+      new DelegatingPaintView(browser_view_->top_container()));
+  mash_reveal_widget_->StackAtTop();
+  mash_reveal_widget_->Show();
+}
+
+void ImmersiveModeControllerAsh::DestroyMashRevealWidget() {
+  mash_reveal_widget_.reset();
+}
+
 void ImmersiveModeControllerAsh::OnImmersiveRevealStarted() {
+  DestroyMashRevealWidget();
+
   visible_fraction_ = 0;
   browser_view_->top_container()->SetPaintToLayer(true);
   browser_view_->top_container()->layer()->SetFillsBoundsOpaquely(false);
   UpdateTabIndicators();
   LayoutBrowserRootView();
+  CreateMashRevealWidget();
   FOR_EACH_OBSERVER(Observer, observers_, OnImmersiveRevealStarted());
 }
 
 void ImmersiveModeControllerAsh::OnImmersiveRevealEnded() {
+  DestroyMashRevealWidget();
   visible_fraction_ = 0;
   browser_view_->top_container()->SetPaintToLayer(false);
   UpdateTabIndicators();
   LayoutBrowserRootView();
 }
 
 void ImmersiveModeControllerAsh::OnImmersiveFullscreenExited() {
+  DestroyMashRevealWidget();
   browser_view_->top_container()->SetPaintToLayer(false);
   UpdateTabIndicators();
   LayoutBrowserRootView();
 }
 
 void ImmersiveModeControllerAsh::SetVisibleFraction(double visible_fraction) {
   if (visible_fraction_ != visible_fraction) {
     visible_fraction_ = visible_fraction;
     browser_view_->Layout();
+
+    if (mash_reveal_widget_) {
+      gfx::Rect bounds = mash_reveal_widget_->GetNativeWindow()->bounds();
+      bounds.set_y(visible_fraction * bounds.height() - bounds.height());
+      mash_reveal_widget_->SetBounds(bounds);
+    }
   }
 }
 
 std::vector<gfx::Rect>
 ImmersiveModeControllerAsh::GetVisibleBoundsInScreen() const {
   views::View* top_container_view = browser_view_->top_container();
   gfx::Rect top_container_view_bounds = top_container_view->GetVisibleBounds();
   // TODO(tdanderson): Implement View::ConvertRectToScreen().
   gfx::Point top_container_view_bounds_in_screen_origin(
       top_container_view_bounds.origin());
@@ skipping 23 matching lines @@
 }
 
 void ImmersiveModeControllerAsh::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
   if (!controller_->IsEnabled())
     return;
 
+  if (chrome::IsRunningInMash()) {
+    // TODO: http://crbug.com/640384.
+    NOTIMPLEMENTED();
+    return;
+  }
+
   bool tab_indicator_visibility_changed = UpdateTabIndicators();
 
   // Auto hide the shelf in immersive browser fullscreen. When auto hidden and
   // Material Design is not enabled, the shelf displays a 3px 'light bar' when
   // it is closed. When in immersive browser fullscreen and tab fullscreen, hide
   // the shelf completely and prevent it from being revealed.
   bool in_tab_fullscreen = content::Source<FullscreenController>(source)->
       IsWindowFullscreenForTabOrPending();
-  ash::wm::GetWindowState(native_window_)
+  ash::wm::GetWindowState(browser_view_->GetNativeWindow())
       ->set_shelf_mode_in_fullscreen(
           in_tab_fullscreen ? ash::wm::WindowState::SHELF_HIDDEN
                             : ash::wm::WindowState::SHELF_AUTO_HIDE_VISIBLE);
   ash::Shell::GetInstance()->UpdateShelfVisibility();
 
   if (tab_indicator_visibility_changed)
     LayoutBrowserRootView();
 }