Introduce very beginning of navigation

mojo/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/basictypes.h"
 #include "base/bind.h"
+#include "base/strings/stringprintf.h"
 #include "mojo/examples/window_manager/window_manager.mojom.h"
 #include "mojo/public/cpp/application/application.h"
+#include "mojo/services/navigation/navigation.mojom.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "mojo/services/public/cpp/view_manager/view_tree_node.h"
 #include "ui/events/event_constants.h"
 
 #if defined CreateWindow
 #undef CreateWindow
 #endif
 
 using mojo::view_manager::Id;
 using mojo::view_manager::View;
 using mojo::view_manager::ViewManager;
 using mojo::view_manager::ViewManagerDelegate;
 using mojo::view_manager::ViewObserver;
 using mojo::view_manager::ViewTreeNode;
 using mojo::view_manager::ViewTreeNodeObserver;
 
 namespace mojo {
 namespace examples {
 
 class WindowManager;
 
+namespace {
+
+const SkColor kColors[] = { SK_ColorYELLOW,
+                            SK_ColorRED,
+                            SK_ColorGREEN,
+                            SK_ColorMAGENTA };
+
+const char* kEmbeddedAppURL = "mojo:mojo_embedded_app";
+
+}  // namespace
+
 class WindowManagerConnection : public InterfaceImpl<IWindowManager> {
  public:
   explicit WindowManagerConnection(WindowManager* window_manager)
       : window_manager_(window_manager) {}
   virtual ~WindowManagerConnection() {}
 
  private:
   // Overridden from IWindowManager:
   virtual void CloseWindow(Id node_id) OVERRIDE;
 
@@ skipping 19 matching lines @@
   // Overridden from Application:
   virtual void Initialize() MOJO_OVERRIDE {
     AddService<WindowManagerConnection>(this);
     ViewManager::Create(this, this);
   }
 
     // Overridden from ViewObserver:
   virtual void OnViewInputEvent(View* view, EventPtr event) OVERRIDE {
     if (event->action == ui::ET_MOUSE_RELEASED) {
       if (event->flags & ui::EF_LEFT_MOUSE_BUTTON)
         CreateWindow("mojo:mojo_embedded_app");

[Ben Goodger (Google), 2014/06/09 20:17:05]

nit: mebbe swap this out with your new kEmbeddedAppURL

[Aaron Boodman, 2014/06/10 19:41:29]

Ugh. Merge fallout. Sorry.

       else if (event->flags & ui::EF_RIGHT_MOUSE_BUTTON)
         CreateWindow("mojo:mojo_nesting_app");
     }
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnRootAdded(ViewManager* view_manager,
                            ViewTreeNode* root) OVERRIDE {
     DCHECK(!view_manager_);
     view_manager_ = view_manager;
@@ skipping 16 matching lines @@
     if (!node->children().empty()) {
       gfx::Point position = node->children().back()->bounds().origin();
       position.Offset(50, 50);
       bounds.set_origin(position);
     }
 
     ViewTreeNode* embedded = ViewTreeNode::Create(view_manager_);
     node->AddChild(embedded);
     embedded->SetBounds(bounds);
     embedded->Embed(url);
+
+    if (!view_navigator_.get()) {
+      // TODO(aa): This means that there can only ever be one instance of every
+      // app, which seems wrong. Instead, perhaps embedder should get back a
+      // service provider that allows it to talk to embeddee.
+      ConnectTo(kEmbeddedAppURL, &view_navigator_);

[Ben Goodger (Google), 2014/06/09 20:17:05]

can't you resolve this by having view_navigator_ be a local & just connect every
time?

[Aaron Boodman, 2014/06/10 19:41:29]

I wasn't referring to the shared member variable. You're right that I can use a
local for this (I had to change something in application.cc for it to work, but
I think that was a bug).

What I was referring to was that connecting by URL implies that the URL alone is
sufficient to identify what you want. I don't think that is the case.

Think of like in Chrome, where we have multiple processes for a given domain. If
we want to support that, connecting by URL isn't going to work...

I think that when embed asks to connect to a service, it should get back a SP.
It should return that SP up to caller, and caller should use that to get the
interfaces it wants. That way both VN and the caller of Embed can be ignorant of
how exactly services are instantiated and shared.

I believe that the exactly rules for how we divvy up services will vary by
service, device, etc.

+    }
+
+    navigation::NavigationDetailsPtr details(
+        navigation::NavigationDetails::New());
+    size_t index = node->children().size() - 1;
+    details->url = base::StringPrintf(
+        "%s/%x", kEmbeddedAppURL, kColors[index % arraysize(kColors)]);
+    view_navigator_->Navigate(embedded->id(), details.Pass());
   }
 
+  navigation::ViewNavigatorPtr view_navigator_;
   ViewManager* view_manager_;
   Id parent_node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 };
 
 void WindowManagerConnection::CloseWindow(Id node_id) {
   window_manager_->CloseWindow(node_id);
 }
 
 }  // namespace examples
 
 // static
 Application* Application::Create() {
   return new examples::WindowManager;
 }
 
-}  // namespace mojo
+}  // namespace mojo