Converts some services to use aura-mus

mash/browser/browser.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 "mash/browser/browser.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "content/public/common/service_names.mojom.h"
 #include "mash/browser/debug_view.h"
 #include "mash/public/interfaces/launchable.mojom.h"
 #include "services/navigation/public/cpp/view.h"
 #include "services/navigation/public/cpp/view_delegate.h"
 #include "services/navigation/public/cpp/view_observer.h"
 #include "services/navigation/public/interfaces/view.mojom.h"
 #include "services/service_manager/public/c/main.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/cpp/service_runner.h"
 #include "services/tracing/public/cpp/provider.h"
-#include "services/ui/public/cpp/window.h"
-#include "services/ui/public/cpp/window_tree_client.h"
-#include "ui/aura/mus/mus_util.h"
+#include "ui/aura/window.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/paint_throbber.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/mus/aura_init.h"
-#include "ui/views/mus/window_manager_connection.h"
+#include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "url/gurl.h"
 
 namespace mash {
 namespace browser {
 
 void EnableButton(views::CustomButton* button, bool enabled) {
   button->SetState(enabled ? views::Button::STATE_NORMAL
                            : views::Button::STATE_DISABLED);
 }
@@ skipping 41 matching lines @@
         view_(std::move(view)) {
     view_->AddObserver(this);
     set_background(new Background(this));
   }
   ~Tab() override {
     view_->RemoveObserver(this);
   }
 
   bool selected() const { return selected_; }
 
-  ui::Window* window() { return window_; }
-  void SetWindow(ui::Window* window) {
+  aura::Window* window() { return window_; }
+  void SetWindow(aura::Window* window) {
     window_ = window;
-    window_->SetVisible(selected_);
+    if (selected_)
+      window_->Show();
+    else
+      window_->Hide();
     view_->EmbedInWindow(window_);
   }
   navigation::View* view() { return view_.get(); }
 
  private:
   // views::View:
   gfx::Size GetPreferredSize() const override {
     gfx::Size ps = views::LabelButton::GetPreferredSize();
     ps.set_width(180);
     return ps;
   }
 
   // navigation::ViewObserver:
   void NavigationStateChanged(navigation::View* view) override {
     if (!view->title().empty())
       SetText(view->title());
   }
 
   // TabStripObserver:
   void OnTabSelected(Tab* selected) override {
     selected_ = selected == this;
     SetTextColor(views::Button::STATE_NORMAL,
                  selected_ ? SK_ColorWHITE : SK_ColorBLACK);
     SetTextColor(views::Button::STATE_HOVERED,
                  selected_ ? SK_ColorWHITE : SK_ColorBLACK);
     SetTextColor(views::Button::STATE_PRESSED,
                  selected_ ? SK_ColorWHITE : SK_ColorBLACK);
-    if (window_)
-      window_->SetVisible(selected_);
+    if (window_) {
+      if (selected_)
+        window_->Show();
+      else
+        window_->Hide();
+    }
   }
 
-  ui::Window* window_ = nullptr;
+  aura::Window* window_ = nullptr;
   std::unique_ptr<navigation::View> view_;
   bool selected_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(Tab);
 };
 
 class TabStrip : public views::View,
                  public views::ButtonListener {
  public:
   class Delegate {
@@ skipping 25 matching lines @@
     tab_container_->SetLayoutManager(tab_container_layout);
     AddChildView(tab_container_);
     layout->SetFlexForView(tab_container_, 1);
     AddChildView(new_tab_button_);
   }
   ~TabStrip() override {
     for (auto* tab : tabs_)
       RemoveObserver(tab);
   }
 
-  void SetContainerWindow(ui::Window* container) {
+  void SetContainerWindow(aura::Window* container) {
     DCHECK(!container_);
     container_ = container;
     for (auto* tab : tabs_) {
-      ui::Window* window = container_->window_tree()->NewWindow();
+      aura::Window* window = new aura::Window(nullptr);
+      window->Init(ui::LAYER_NOT_DRAWN);
       container_->AddChild(window);
       tab->SetWindow(window);
     }
   }
 
   void AddTab(std::unique_ptr<navigation::View> view) {
     selected_index_ = static_cast<int>(tabs_.size());
     Tab* tab = new Tab(std::move(view), this);
     // We won't have a WindowTree until we're added to a view hierarchy.
     if (container_) {
-      ui::Window* window = container_->window_tree()->NewWindow();
+      aura::Window* window = new aura::Window(nullptr);
+      window->Init(ui::LAYER_NOT_DRAWN);
       container_->AddChild(window);
       tab->SetWindow(window);
     }
     AddObserver(tab);
     tabs_.push_back(tab);
     tab_container_->AddChildView(tab);
     for (auto& observer : observers_)
       observer.OnTabAdded(tab);
     SelectTab(tab);
   }
@@ skipping 71 matching lines @@
     else if (sender == new_tab_button_ && delegate_)
       delegate_->NewTab();
   }
 
   Delegate* delegate_;
   views::View* tab_container_;
   views::LabelButton* new_tab_button_;
   std::vector<Tab*> tabs_;
   int selected_index_ = -1;
   base::ObserverList<TabStripObserver> observers_;
-  ui::Window* container_ = nullptr;
+  aura::Window* container_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(TabStrip);
 };
 
 class NavMenuModel : public ui::MenuModel {
  public:
   class Delegate {
    public:
     virtual void NavigateToOffset(int offset) = 0;
   };
@@ skipping 367 matching lines @@
       int height = local_bounds.height() - y - debug_view_height;
       content_area_->SetBounds(
           gfx::Rect(offset.x(), offset.y(), width, height));
       for (auto* child : content_area_->children())
         child->SetBounds(gfx::Rect(0, 0, width, height));
     }
   }
   void ViewHierarchyChanged(
       const views::View::ViewHierarchyChangedDetails& details) override {
     if (details.is_add && GetWidget() && !content_area_) {
-      ui::Window* window = aura::GetMusWindow(GetWidget()->GetNativeWindow());
-      content_area_ = window->window_tree()->NewWindow(nullptr);
-      content_area_->SetVisible(true);
+      aura::Window* window = GetWidget()->GetNativeWindow();
+      content_area_ = new aura::Window(nullptr);
+      content_area_->Init(ui::LAYER_NOT_DRAWN);
+      content_area_->Show();
       window->AddChild(content_area_);
       tab_strip_->SetContainerWindow(content_area_);
     }
   }
 
   // Overridden from views::TextFieldController:
   bool HandleKeyEvent(views::Textfield* sender,
                       const ui::KeyEvent& key_event) override {
     if (key_event.type() == ui::ET_KEY_PRESSED &&
         key_event.key_code() == ui::VKEY_RETURN)
@@ skipping 137 matching lines @@
 
   TabStrip* tab_strip_;
   views::LabelButton* back_button_;
   views::LabelButton* forward_button_;
   views::LabelButton* reload_button_;
   views::Textfield* prompt_;
   views::LabelButton* debug_button_;
   Throbber* throbber_;
   ProgressBar* progress_bar_;
 
-  ui::Window* content_area_ = nullptr;
+  aura::Window* content_area_ = nullptr;
 
   DebugView* debug_view_;
   bool showing_debug_view_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(UI);
 };
 
 Browser::Browser() {}
 Browser::~Browser() {}
 
@@ skipping 13 matching lines @@
   navigation::mojom::ViewFactoryPtr factory;
   context()->connector()->ConnectToInterface(
       content::mojom::kBrowserServiceName, &factory);
   return base::MakeUnique<navigation::View>(std::move(factory));
 }
 
 void Browser::OnStart() {
   tracing_.Initialize(context()->connector(), context()->identity().name());
 
   aura_init_ = base::MakeUnique<views::AuraInit>(
-      context()->connector(), context()->identity(), "views_mus_resources.pak");
-  window_manager_connection_ = views::WindowManagerConnection::Create(
-      context()->connector(), context()->identity());
+      context()->connector(), context()->identity(), "views_mus_resources.pak",
+      std::string(), nullptr, views::AuraInit::Mode::AURA_MUS);
 }
 
 bool Browser::OnConnect(const service_manager::ServiceInfo& remote_info,
                         service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::Launchable>(this);
   return true;
 }
 
 void Browser::Launch(uint32_t what, mojom::LaunchMode how) {
   bool reuse =
@@ skipping 11 matching lines @@
   AddWindow(window);
 }
 
 void Browser::Create(const service_manager::Identity& remote_identity,
                      mojom::LaunchableRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace browser
 }  // namespace mash