Expose NavigatorHost via Embed() rather than globally.

mojo/examples/media_viewer/media_viewer.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 <map>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 168 matching lines @@
       }
     }
   }
 
   Delegate* delegate_;
   views::Button* buttons_[CONTROL_COUNT];
 
   DISALLOW_COPY_AND_ASSIGN(ControlPanel);
 };
 
-class NavigatorImpl : public InterfaceImpl<Navigator> {

[Aaron Boodman, 2014/09/04 08:02:59]

MediaViewer was already broken from previous changes, this just keeps it
compiling. It is a TODO to make it work again for real.

It's a slightly bigger project because it needs to change conceptually now that
we don't have a distinction between application and navigation URLs.

- public:
-  explicit NavigatorImpl(MediaViewer* viewer) : viewer_(viewer) {}
-  virtual ~NavigatorImpl() {}
-
- private:
-  // Overridden from Navigator:
-  virtual void Navigate(
-      uint32_t view_id,
-      NavigationDetailsPtr navigation_details,
-      ResponseDetailsPtr response_details) OVERRIDE;
-
-  MediaViewer* viewer_;
-
-  DISALLOW_COPY_AND_ASSIGN(NavigatorImpl);
-};
-
 class MediaViewer
     : public ApplicationDelegate,
       public ViewManagerDelegate,
       public ControlPanel::Delegate,
       public ViewObserver {
  public:
   MediaViewer()
-      : navigator_factory_(this),
-        app_(NULL),
+      : app_(NULL),
         view_manager_(NULL),
         root_view_(NULL),
         control_view_(NULL),
         content_view_(NULL),
         control_panel_(this) {
     handler_map_["image/png"] = "mojo:mojo_png_viewer";
   }
 
   virtual ~MediaViewer() {
     if (root_view_)
       root_view_->RemoveObserver(this);
   }
 
-  void Navigate(
-      uint32_t view_id,
-      NavigationDetailsPtr navigation_details,
-      ResponseDetailsPtr response_details) {
-    // TODO(yzshen): This shouldn't be needed once FIFO is ready.
-    if (!view_manager_) {
-      pending_navigate_request_.reset(new PendingNavigateRequest);
-      pending_navigate_request_->view_id = view_id;
-      pending_navigate_request_->navigation_details = navigation_details.Pass();
-      pending_navigate_request_->response_details = response_details.Pass();
-
-      return;
-    }
-
-    std::string handler = GetHandlerForContentType(
-        response_details->response->mime_type);
-    if (handler.empty())
-      return;
-
-    content_view_->Embed(handler);
-
-    if (navigation_details) {
-      NavigatorPtr navigator;
-      app_->ConnectToService(handler, &navigator);
-      navigator->Navigate(content_view_->id(), navigation_details.Pass(),
-                          response_details.Pass());
-    }
-
-    // TODO(yzshen): determine the set of controls to show based on what
-    // interfaces the embedded app provides.
-    app_->ConnectToService(handler, &zoomable_media_);
-  }
-
  private:
   typedef std::map<std::string, std::string> HandlerMap;
 
   struct PendingNavigateRequest {
     uint32_t view_id;
     NavigationDetailsPtr navigation_details;
     ResponseDetailsPtr response_details;
   };
 
 
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) OVERRIDE {
     view_manager_client_factory_.reset(
         new ViewManagerClientFactory(app->shell(), this));
     app_ = app;
     views_init_.reset(new ViewsInit);
   }
 
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       OVERRIDE {
-    connection->AddService(&navigator_factory_);
     connection->AddService(view_manager_client_factory_.get());
     return true;
   }
 
   void LayoutViews() {
     View* root = content_view_->parent();
     gfx::Rect control_bounds(root->bounds().width(), 28);
     control_view_->SetBounds(control_bounds);
     gfx::Rect content_bounds(0, control_bounds.height(), root->bounds().width(),
                              root->bounds().height() - control_bounds.height());
@@ skipping 12 matching lines @@
     root_view_->AddChild(control_view_);
 
     content_view_ = View::Create(view_manager_);
     root_view_->AddChild(content_view_);
 
     control_panel_.Initialize(control_view_);
 
     LayoutViews();
     root_view_->AddObserver(this);
 
-    if (pending_navigate_request_) {
-      scoped_ptr<PendingNavigateRequest> request(
-          pending_navigate_request_.release());
+    content_view_->Embed("TODO");
+  }
 
-      Navigate(request->view_id, request->navigation_details.Pass(),
-               request->response_details.Pass());
-    }
-  }
   virtual void OnViewManagerDisconnected(
       ViewManager* view_manager) OVERRIDE {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from ControlPanel::Delegate:
   virtual void ButtonPressed(ControlPanel::ControlType type) OVERRIDE {
     switch (type) {
@@ skipping 21 matching lines @@
     DCHECK_EQ(view, root_view_);
     view->RemoveObserver(this);
     root_view_ = NULL;
   }
 
   std::string GetHandlerForContentType(const std::string& content_type) {
     HandlerMap::const_iterator it = handler_map_.find(content_type);
     return it != handler_map_.end() ? it->second : std::string();
   }
 
-  InterfaceFactoryImplWithContext<NavigatorImpl, MediaViewer>
-      navigator_factory_;
   scoped_ptr<ViewManagerClientFactory> view_manager_client_factory_;
 
   ApplicationImpl* app_;
   scoped_ptr<ViewsInit> views_init_;
   ViewManager* view_manager_;
   View* root_view_;
   View* control_view_;
   View* content_view_;
   ControlPanel control_panel_;
   ZoomableMediaPtr zoomable_media_;
   HandlerMap handler_map_;
-  scoped_ptr<PendingNavigateRequest> pending_navigate_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaViewer);
 };
 
-void NavigatorImpl::Navigate(
-    uint32_t view_id,
-    NavigationDetailsPtr navigation_details,
-    ResponseDetailsPtr response_details) {
-  viewer_->Navigate(view_id, navigation_details.Pass(),
-                    response_details.Pass());
-}
-
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::MediaViewer);
   return runner.Run(shell_handle);
 }