Draggable peeking/fullscreen launcher with transparent background.

ash/shell.cc

 // Copyright (c) 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 "ash/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_delegate.h"
 #include "ash/accelerators/ash_focus_manager_factory.h"
 #include "ash/accelerators/magnifier_key_scroller.h"
 #include "ash/accelerators/spoken_feedback_toggler.h"
 #include "ash/accessibility_delegate.h"
-#include "ash/app_list/app_list_delegate_impl.h"
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/aura/shell_port_classic.h"
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/cast_config_controller.h"
 #include "ash/devtools/ash_devtools_css_agent.h"
 #include "ash/devtools/ash_devtools_dom_agent.h"
 #include "ash/display/cursor_window_controller.h"
 #include "ash/display/display_color_manager_chromeos.h"
 #include "ash/display/display_configuration_controller.h"
@@ skipping 451 matching lines @@
   return app_list_->GetTargetVisibility();
 }
 
 void Shell::UpdateAfterLoginStatusChange(LoginStatus status) {
   for (WmWindow* root_window : shell_port_->GetAllRootWindows()) {
     root_window->GetRootWindowController()->UpdateAfterLoginStatusChange(
         status);
   }
 }
 
+void Shell::NotifyAppListVisibilityChanged(bool shown,
+                                           aura::Window* root_window) {
+  for (auto& observer : shell_observers_)
+    observer.OnAppListVisibilityChanged(shown, root_window);
+}
+
 void Shell::NotifyMaximizeModeStarted() {
   for (auto& observer : shell_observers_)
     observer.OnMaximizeModeStarted();
 }
 
 void Shell::NotifyMaximizeModeEnding() {
   for (auto& observer : shell_observers_)
     observer.OnMaximizeModeEnding();
 }
 
@@ skipping 90 matching lines @@
   // state on ShellPortClassic. http://crbug.com/671246.
 
   gpu_support_.reset(shell_delegate_->CreateGPUSupport());
 
   // Don't use Shell::GetAshConfig() as |instance_| has not yet been set.
   if (shell_port_->GetAshConfig() != Config::MASH) {
     display_manager_.reset(ScreenAsh::CreateDisplayManager());
     window_tree_host_manager_.reset(new WindowTreeHostManager);
     user_metrics_recorder_.reset(new UserMetricsRecorder);
   }
+  app_list()->set_delegate(this);
 
   PowerStatus::Initialize();
 
   session_controller_->AddObserver(this);
 }
 
 Shell::~Shell() {
   TRACE_EVENT0("shutdown", "ash::Shell::Destructor");
 
   const Config config = shell_port_->GetAshConfig();
 
   if (config != Config::MASH)
     user_metrics_recorder_->OnShellShuttingDown();
 
+  app_list()->set_delegate(nullptr);

[sky, 2017/06/07 20:21:36]

Document why this this is necessary. In particular, if this is ordering
dependent what it depends on.

[newcomer, 2017/06/08 21:59:05]

Done.

+
   shell_delegate_->PreShutdown();
 
   // Remove the focus from any window. This will prevent overhead and side
   // effects (e.g. crashes) from changing focus during shutdown.
   // See bug crbug.com/134502.
   aura::client::GetFocusClient(GetPrimaryRootWindow())->FocusWindow(nullptr);
 
   // Please keep in same order as in Init() because it's easy to miss one.
   if (window_modality_controller_)
     window_modality_controller_.reset();
@@ skipping 96 matching lines @@
   laser_pointer_controller_.reset();
   partial_magnification_controller_.reset();
 
   // This also deletes all RootWindows. Note that we invoke Shutdown() on
   // WindowTreeHostManager before resetting |window_tree_host_manager_|, since
   // destruction
   // of its owned RootWindowControllers relies on the value.
   ScreenAsh::CreateScreenForShutdown();
   display_configuration_controller_.reset();
 
-  // AppListDelegateImpl depends upon AppList.
-  app_list_delegate_impl_.reset();
-
   // These members access Shell in their destructors.
   wallpaper_controller_.reset();
   accessibility_delegate_.reset();
 
   // Balances the Install() in Initialize().
   views::FocusManagerFactory::Install(nullptr);
 
   // ShelfWindowWatcher has window observers and a pointer to the shelf model.
   shelf_window_watcher_.reset();
 
@@ skipping 87 matching lines @@
     auto dom_backend = base::MakeUnique<devtools::AshDevToolsDOMAgent>();
     auto css_backend =
         base::MakeUnique<devtools::AshDevToolsCSSAgent>(dom_backend.get());
     auto devtools_client = base::MakeUnique<ui::devtools::UiDevToolsClient>(
         "Ash", devtools_server_.get());
     devtools_client->AddAgent(std::move(dom_backend));
     devtools_client->AddAgent(std::move(css_backend));
     devtools_server_->AttachClient(std::move(devtools_client));
   }
 
-  if (config == Config::MASH)
-    app_list_delegate_impl_ = base::MakeUnique<AppListDelegateImpl>();
-
   // TODO(sky): move creation to ShellPort.
   if (config != Config::MASH)
     immersive_handler_factory_ = base::MakeUnique<ImmersiveHandlerFactoryAsh>();
 
   window_positioner_ = base::MakeUnique<WindowPositioner>();
 
   if (config == Config::CLASSIC) {
     // TODO: needs to work in mus. http://crbug.com/705592.
     native_cursor_manager_ = new AshNativeCursorManager;
     cursor_manager_.reset(
@@ skipping 359 matching lines @@
 }
 
 void Shell::OnWindowActivated(
     ::wm::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active)
     root_window_for_new_windows_ = gained_active->GetRootWindow();
 }
 
+void Shell::OnAppListVisibilityChanged(bool visible, int64_t display_id) {
+  NotifyAppListVisibilityChanged(
+      visible, ShellPort::Get()->GetRootWindowForDisplayId(display_id));
+}
+
 void Shell::OnSessionStateChanged(session_manager::SessionState state) {
   // Initialize the shelf when a session becomes active. It's safe to do this
   // multiple times (e.g. initial login vs. multiprofile add session).
   if (state == session_manager::SessionState::ACTIVE) {
     InitializeShelf();
     if (GetAshConfig() != Config::MASH) {
       // Recreate the keyboard after initial login and after multiprofile login.
       CreateKeyboard();
     }
   }
@@ skipping 34 matching lines @@
 void Shell::OnPrefServiceInitialized(
     std::unique_ptr<::PrefService> pref_service) {
   if (!instance_)
     return;
   // |pref_service_| is null if can't connect to Chrome (as happens when
   // running mash outside of chrome --mash and chrome isn't built).
   pref_service_ = std::move(pref_service);
 }
 
 }  // namespace ash