Rebuild the debug panel in the browser demo with sky.

examples/window_manager/window_manager.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/macros.h"
 #include "examples/keyboard/keyboard.mojom.h"
-#include "examples/window_manager/debug_panel.h"
+#include "examples/window_manager/debug_panel_host.mojom.h"
 #include "examples/window_manager/window_manager.mojom.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory_impl.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/services/input_events/public/interfaces/input_events.mojom.h"
 #include "mojo/services/navigation/public/interfaces/navigation.mojom.h"
 #include "mojo/services/view_manager/public/cpp/view.h"
 #include "mojo/services/view_manager/public/cpp/view_manager.h"
 #include "mojo/services/view_manager/public/cpp/view_manager_delegate.h"
 #include "mojo/services/view_manager/public/cpp/view_observer.h"
-#include "mojo/views/views_init.h"
 #include "services/window_manager/basic_focus_rules.h"
 #include "services/window_manager/view_target.h"
 #include "services/window_manager/window_manager_app.h"
 #include "services/window_manager/window_manager_delegate.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/geometry/size_conversions.h"
+#include "url/gurl.h"
 
 #if defined CreateWindow
 #undef CreateWindow
 #endif
 
 namespace mojo {
 namespace examples {
 
 class WindowManager;
 
@@ skipping 203 matching lines @@
                       InterfaceRequest<NavigatorHost> request) override {
     BindToRequest(new NavigatorHostImpl(window_manager_, view_->id()),
                   &request);
   }
 
   WindowManager* window_manager_;
   View* view_;
 };
 
 class WindowManager : public ApplicationDelegate,
-                      public DebugPanel::Delegate,
+                      public examples::DebugPanelHost,
                       public ViewManagerDelegate,
                       public window_manager::WindowManagerDelegate,
-                      public ui::EventHandler {
+                      public ui::EventHandler,
+                      public mojo::InterfaceFactory<examples::DebugPanelHost> {
  public:
   WindowManager()
       : shell_(nullptr),
         window_manager_factory_(this),
         launcher_ui_(NULL),
         view_manager_(NULL),
         window_manager_app_(new window_manager::WindowManagerApp(this, this)),
-        app_(NULL) {}
+        navigation_target_(TARGET_DEFAULT),
+        app_(NULL),
+        binding_(this) {}
 
   virtual ~WindowManager() {
     // host() may be destroyed by the time we get here.
     // TODO: figure out a way to always cleanly remove handler.
 
     // TODO(erg): In the aura version, we removed ourselves from the
     // PreTargetHandler list here. We may need to do something analogous when
     // we get event handling without aura working.
   }
 
@@ skipping 30 matching lines @@
     // See comment in ShowKeyboard() about validating args.
     if (keyboard_manager_)
       keyboard_manager_->Hide(view_id);
   }
 
   void DidNavigateLocally(uint32 source_view_id, const mojo::String& url) {
     LOG(ERROR) << "DidNavigateLocally: source_view_id: " << source_view_id
                << " url: " << url.To<std::string>();
   }
 
-  // Overridden from DebugPanel::Delegate:
-  virtual void CloseTopWindow() override {
+  void RequestNavigate(uint32 source_view_id,
+                       Target target,
+                       URLRequestPtr request) {
+    OnLaunch(source_view_id, target, request->url);
+  }
+
+  // Overridden from mojo::DebugPanelHost:
+  void CloseTopWindow() override {
     if (!windows_.empty())
       CloseWindow(windows_.back()->view()->id());
   }
 
-  virtual void RequestNavigate(uint32 source_view_id,
-                               Target target,
-                               URLRequestPtr request) override {
-    OnLaunch(source_view_id, target, request->url);
+  void NavigateTo(const String& url) override {
+    OnLaunch(control_panel_id_, TARGET_NEW_NODE, url);
+  }
+
+  void SetNavigationTarget(Target t) override {
+    navigation_target_ = t;
+  }
+
+  // mojo::InterfaceFactory<examples::DebugPanelHost> implementation.
+  void Create(
+      mojo::ApplicationConnection* connection,
+      mojo::InterfaceRequest<examples::DebugPanelHost> request) override {
+    binding_.Bind(request.Pass());
   }
 
  private:
   typedef std::vector<Window*> WindowVector;
 
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) override {
     shell_ = app->shell();
     app_ = app;
-    views_init_.reset(new ViewsInit);
+    // FIXME: Mojo applications don't know their URLs yet:
+    // https://docs.google.com/a/chromium.org/document/d/1AQ2y6ekzvbdaMF5WrUQmneyXJnke-MnYYL4Gz1AKDos
+    url_ = GURL(app->args()[1]);
     window_manager_app_->Initialize(app);
   }
 
   virtual bool ConfigureIncomingConnection(
       ApplicationConnection* connection) override {
     connection->AddService(&window_manager_factory_);
     window_manager_app_->ConfigureIncomingConnection(connection);
     return true;
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnEmbed(View* root,
                        ServiceProviderImpl* exported_services,
                        scoped_ptr<ServiceProvider> imported_services) override {
     DCHECK(!view_manager_);
     view_manager_ = root->view_manager();
 
     View* view = view_manager_->CreateView();
     root->AddChild(view);
     Rect rect;
     rect.width = root->bounds().width;
     rect.height = root->bounds().height;
     view->SetBounds(rect);
     view->SetVisible(true);
     content_view_id_ = view->id();
 
     Id launcher_ui_id = CreateLauncherUI();
-    Id control_panel_id = CreateControlPanel(view);
+    control_panel_id_ = CreateControlPanel(view);
 
     root_layout_manager_.reset(
         new RootLayoutManager(view_manager_, root, content_view_id_,
-                              launcher_ui_id, control_panel_id));
+                              launcher_ui_id, control_panel_id_));
     root->AddObserver(root_layout_manager_.get());
 
     // TODO(erg): In the aura version, we explicitly added ourselves as a
     // PreTargetHandler to the window() here. We probably have to do something
     // analogous here.
 
     window_manager_app_->InitFocus(
         make_scoped_ptr(new window_manager::BasicFocusRules(view)));
   }
   virtual void OnViewManagerDisconnected(ViewManager* view_manager) override {
@@ skipping 16 matching lines @@
         static_cast<window_manager::ViewTarget*>(event->target())->view();
     if (event->type() == ui::ET_MOUSE_PRESSED &&
         !IsDescendantOfKeyboard(view)) {
       view->SetFocus();
     }
   }
 
   void OnLaunch(uint32 source_view_id,
                 Target requested_target,
                 const mojo::String& url) {
-    Target target = debug_panel_->navigation_target();
+    Target target = navigation_target_;
     if (target == TARGET_DEFAULT) {
       if (requested_target != TARGET_DEFAULT) {
         target = requested_target;
       } else {
         // TODO(aa): Should be TARGET_NEW_NODE if source origin and dest origin
         // are different?
         target = TARGET_SOURCE_NODE;
       }
     }
 
@@ skipping 64 matching lines @@
 
     Rect bounds;
     bounds.x = root->bounds().width - kControlPanelWidth - kBorderInset;
     bounds.y = kBorderInset * 2 + kTextfieldHeight;
     bounds.width = kControlPanelWidth;
     bounds.height =
         root->bounds().height - kBorderInset * 3 - kTextfieldHeight;
     view->SetBounds(bounds);
     view->SetVisible(true);
 
-    debug_panel_ = new DebugPanel(this, shell_, view);
+    scoped_ptr<mojo::ServiceProviderImpl> exported_services(
+        new mojo::ServiceProviderImpl());
+    exported_services->AddService(this);
+
+    GURL frame_url = url_.Resolve("/examples/window_manager/debug_panel.sky");
+    debug_panel_ = view->Embed(frame_url.spec(), exported_services.Pass());
+
     return view->id();
   }
 
   WindowVector::iterator GetWindowByViewId(Id view_id) {
     for (std::vector<Window*>::iterator iter = windows_.begin();
          iter != windows_.end();
          ++iter) {
       if ((*iter)->view()->id() == view_id) {
         return iter;
       }
     }
     return windows_.end();
   }
 
   Shell* shell_;
 
   InterfaceFactoryImplWithContext<WindowManagerConnection, WindowManager>
       window_manager_factory_;
 
-  scoped_ptr<ViewsInit> views_init_;
-  DebugPanel* debug_panel_;
+  scoped_ptr<mojo::ServiceProvider> debug_panel_;
   Window* launcher_ui_;
   WindowVector windows_;
   ViewManager* view_manager_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
   scoped_ptr<window_manager::WindowManagerApp> window_manager_app_;
 
   // Id of the view most content is added to. The keyboard is NOT added here.
   Id content_view_id_;
 
+  // Id of the debug panel.
+  Id control_panel_id_;
+
+  GURL url_;
+  Target navigation_target_;
+
   scoped_ptr<KeyboardManager> keyboard_manager_;
   ApplicationImpl* app_;
 
+  mojo::Binding<examples::DebugPanelHost> binding_;
+
   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 };
 
 void WindowManagerConnection::CloseWindow(Id view_id) {
   window_manager_->CloseWindow(view_id);
 }
 
 void WindowManagerConnection::ShowKeyboard(Id view_id, RectPtr bounds) {
   window_manager_->ShowKeyboard(view_id, *bounds);
 }
@@ skipping 10 matching lines @@
   window_manager_->RequestNavigate(view_id_, target, request.Pass());
 }
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::WindowManager);
   return runner.Run(shell_handle);
 }