Mojo: teach launcher about mojo:// URLs.

mojo/services/launcher/launcher.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/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_tokenizer.h"
 #include "mojo/public/cpp/application/application.h"
 #include "mojo/services/public/cpp/view_manager/types.h"
 #include "mojo/services/public/interfaces/launcher/launcher.mojom.h"
 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
 #include "mojo/services/public/interfaces/network/url_loader.mojom.h"
+#include "url/gurl.h"
 
 namespace mojo {
 namespace launcher {
 
 class LauncherApp;
 
 class LauncherConnection : public InterfaceImpl<Launcher> {
  public:
   explicit LauncherConnection(LauncherApp* app) : app_(app) {}
   virtual ~LauncherConnection() {}
@@ skipping 46 matching lines @@
   void ScheduleDestroy() {
     if (destroy_scheduled_)
       return;
     destroy_scheduled_ = true;
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
   LauncherApp* app_;
   bool destroy_scheduled_;
   LauncherClient* client_;
+  String url_;
   URLLoaderPtr url_loader_;
   ScopedDataPipeConsumerHandle response_body_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(LaunchInstance);
 };
 
 class LauncherApp : public Application {
  public:
   LauncherApp() {
     handler_map_["text/html"] = "mojo:mojo_html_viewer";
@@ skipping 21 matching lines @@
     ConnectTo("mojo:mojo_network_service", &network_service_);
   }
 
   HandlerMap handler_map_;
 
   NetworkServicePtr network_service_;
 
   DISALLOW_COPY_AND_ASSIGN(LauncherApp);
 };
 
-void LauncherConnection::Launch(const String& url) {
-  new LaunchInstance(app_, client(), url);
+void LauncherConnection::Launch(const String& url_string) {
+  GURL url(url_string.To<std::string>());
+
+  // For Mojo URLs, the handler can always be found at the origin.
+  // TODO(aa): Return error for invalid URL?
+  if (url.is_valid() && url.SchemeIs("mojo")) {

[Ben Goodger (Google), 2014/06/19 21:09:47]

I think this is fine for now, but note that when a mojo URL is defined as
resolving to a HTTP URL, we'll have to fall back to the other branch. Really we
need the shell to expose its resolver perhaps.

[Aaron Boodman, 2014/06/19 21:25:12]

Hm, ok.

I didn't realize/remember we wanted mojo URLs to fall back to http. Why is that?
I mean, why not just reference them directly at the HTTP URL in the first place?

+    client()->OnLaunch(url_string,
+                       url.GetOrigin().spec(),
+                       navigation::ResponseDetailsPtr());
+    return;
+  }
+
+  new LaunchInstance(app_, client(), url_string);
 }
 
 LaunchInstance::LaunchInstance(LauncherApp* app,
                                LauncherClient* client,
                                const String& url)
     : app_(app),
       destroy_scheduled_(false),
-      client_(client) {
+      client_(client),
+      url_(url) {
   url_loader_ = app_->CreateURLLoader();
   url_loader_.set_client(this);
 
   URLRequestPtr request(URLRequest::New());
   request->url = url;
   request->method = "GET";
   request->auto_follow_redirects = true;
 
   DataPipe data_pipe;
   response_body_stream_ = data_pipe.consumer_handle.Pass();
 
   url_loader_->Start(request.Pass(), data_pipe.producer_handle.Pass());
 }
 
 void LaunchInstance::OnReceivedResponse(URLResponsePtr response) {
   std::string content_type = GetContentType(response->headers);
   std::string handler_url = app_->GetHandlerForContentType(content_type);
   if (!handler_url.empty()) {
-    client_->OnLaunch(handler_url, response.Pass(),
-                      response_body_stream_.Pass());
+    navigation::ResponseDetailsPtr nav_response(
+        navigation::ResponseDetails::New());
+    nav_response->response = response.Pass();
+    nav_response->response_body_stream = response_body_stream_.Pass();
+    client_->OnLaunch(url_, handler_url, nav_response.Pass());
   }
 }
 
 }  // namespace launcher
 
 // static
 Application* Application::Create() {
   return new launcher::LauncherApp;
 }
 
 }  // namespace mojo