Allow the mojo shell to run on android.

mojo/shell/mojo_url_resolver.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 "mojo/shell/mojo_url_resolver.h"
 
 #include "base/base_paths.h"
 #include "base/files/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "net/base/filename_util.h"
 #include "url/url_util.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
-std::string MakeSharedLibraryName(const std::string& host_name) {
+void MakeSharedLibraryNames(const std::string& host_name,
+                            std::vector<std::string>* names) {
 #if defined(OS_WIN)
-  return host_name + ".dll";
+  names->push_back(host_name + ".dll");
 #elif defined(OS_LINUX) || defined(OS_ANDROID)
-  return "lib" + host_name + ".so";
+  names->push_back("lib" + host_name + ".so");
+#if defined(OS_ANDROID)
+  names->push_back("lib" + host_name + ".cr.so");

[qsr, 2014/06/26 12:31:47]

The component build on android names its library .cr.so, See build/common.gypi

[viettrungluu, 2014/06/26 16:59:57]

So I learned that we're probably doing it wrong, and our apps should probably be
built with (gyp) target type "loadable_module" instead of "shared_library". This
allows an app (or whatever) to depend on another app without linking with it.

I don't think common.gypi names loadable_modules with the extension .cr.so (but
who can tell anything from .gyp(i) files?), in which case this change might be
unneeded (assuming we correct all our apps to be built as loadable_modules
instead).

(On the other hand, perhaps it's common.gypi that should be corrected to also
name loadable_modules .cr.so....)

[qsr, 2014/06/27 11:18:18]

 Hum... Very nice. That also probably explain my issues with the non component
build. I'll took another stab at it.

 For this, we then do not need this hack, nor .cr.so. The change of name is to
prevent conflict with some system libraries. There is no reason for loadable
module to conflict with system library, so we should name those .so.

+#endif
 #elif defined(OS_MACOSX)
-  return "lib" + host_name + ".dylib";
+  names->push_back("lib" + host_name + ".dylib");
 #else
   NOTREACHED() << "dynamic loading of services not supported";
-  return std::string();
 #endif
 }
 
 }  // namespace
 
 MojoURLResolver::MojoURLResolver() {
   // Needed to treat first component of mojo URLs as host, not path.
   url::AddStandardScheme("mojo");
 }
 
 MojoURLResolver::~MojoURLResolver() {
 }
 
 void MojoURLResolver::AddCustomMapping(const GURL& mojo_url,
                                        const GURL& resolved_url) {
   url_map_[mojo_url] = resolved_url;
 }
 
 void MojoURLResolver::AddLocalFileMapping(const GURL& mojo_url) {
   local_file_set_.insert(mojo_url);
 }
 
 GURL MojoURLResolver::Resolve(const GURL& mojo_url) const {
   std::map<GURL, GURL>::const_iterator it = url_map_.find(mojo_url);
   if (it != url_map_.end())
     return it->second;
 
-  std::string lib = MakeSharedLibraryName(mojo_url.host());
+
+  std::vector<std::string> libs;
+  MakeSharedLibraryNames(mojo_url.host(), &libs);
+  DCHECK(!libs.empty());
 
   if (local_file_set_.find(mojo_url) != local_file_set_.end()) {
     // Resolve to a local file URL.
-    base::FilePath path;
+    base::FilePath base_path;
 #if defined(OS_ANDROID)
     // On Android, additional lib are bundled.
-    PathService::Get(base::DIR_MODULE, &path);
+    PathService::Get(base::DIR_MODULE, &base_path);
 #else
-    PathService::Get(base::DIR_EXE, &path);
+    PathService::Get(base::DIR_EXE, &base_path);
 #if !defined(OS_WIN)
-    path = path.Append(FILE_PATH_LITERAL("lib"));
+    base_path = base_path.Append(FILE_PATH_LITERAL("lib"));
 #endif  // !defined(OS_WIN)
 #endif  // defined(OS_ANDROID)
-    path = path.Append(base::FilePath::FromUTF8Unsafe(lib));
-    return net::FilePathToFileURL(path);
+    for (std::vector<std::string>::iterator it = libs.begin(); it != libs.end();
+         ++it) {
+      base::FilePath path =
+          base_path.Append(base::FilePath::FromUTF8Unsafe(*it));
+      if (base::PathExists(path)) {
+        return net::FilePathToFileURL(path);
+      }
+    }
   }
 
   // Otherwise, resolve to an URL relative to origin_.
-  return GURL(origin_ + "/" + lib);
+  return GURL(origin_ + "/" + libs[0]);
 }
 
 }  // namespace shell
 }  // namespace mojo