[Android] Abandon bundling DevTools frontends for mobile apps

chrome/browser/android/dev_tools_server.cc

 // Copyright (c) 2012 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 "chrome/browser/android/dev_tools_server.h"
 
 #include <pwd.h>
 #include <cstring>
 
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/devtools/devtools_adb_bridge.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/android/tab_model/tab_model.h"
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
-#include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/android/devtools_auth.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_http_handler.h"
 #include "content/public/browser/devtools_http_handler_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "grit/devtools_discovery_page_resources.h"
 #include "jni/DevToolsServer_jni.h"
 #include "net/socket/unix_domain_socket_posix.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "webkit/common/user_agent/user_agent_util.h"
 
 namespace {
 
 const char kFrontEndURL[] =
-    "http://chrome-devtools-frontend.appspot.com/static/%s/devtools.html";
-const char kDefaultSocketName[] = "chrome_devtools_remote";
+    "http://chrome-devtools-frontend.appspot.com/serve_rev/%s/devtools.html";

[bulach, 2013/06/21 09:02:17]

nit: is "serve" correct or should it be serve"r"?

[mnaganov (inactive), 2013/06/21 09:21:45]

It is correct. It's not a "server revision", but rather a command to "serve by
the revision". But thanks for looking at this!

+const char kDefaultSocketNamePrefix[] = "chrome";

[bulach, 2013/06/21 09:02:17]

as above, would telemetry need to change? it tries to be backward compatible,
i.e., new telemetry versus old browser, would it be possible to detect this
somehow?

[mnaganov (inactive), 2013/06/21 09:21:45]

No. Please note from the var name change, that it is now a prefix added to
"_devtools_remote".

 const char kTetheringSocketName[] = "chrome_devtools_tethering_%d_%d";
 
 // Delegate implementation for the devtools http handler on android. A new
 // instance of this gets created each time devtools is enabled.
 class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
  public:
-  explicit DevToolsServerDelegate(bool use_bundled_frontend_resources)
-      : use_bundled_frontend_resources_(use_bundled_frontend_resources),
-        last_tethering_socket_(0) {
+  DevToolsServerDelegate()
+      : last_tethering_socket_(0) {
   }
 
   virtual std::string GetDiscoveryPageHTML() OVERRIDE {
     // TopSites updates itself after a delay. Ask TopSites to update itself
     // when we're about to show the remote debugging landing page.
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsServerDelegate::PopulatePageThumbnails));
     return ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_DEVTOOLS_DISCOVERY_PAGE_HTML).as_string();
   }
 
   virtual bool BundlesFrontendResources() OVERRIDE {
-    return use_bundled_frontend_resources_;
+    return false;
   }
 
   virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
     return base::FilePath();
   }
 
   virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE {
     Profile* profile =
         ProfileManager::GetLastUsedProfile()->GetOriginalProfile();
     history::TopSites* top_sites = profile->GetTopSites();
@@ skipping 41 matching lines @@
 
  private:
   static void PopulatePageThumbnails() {
     Profile* profile =
         ProfileManager::GetLastUsedProfile()->GetOriginalProfile();
     history::TopSites* top_sites = profile->GetTopSites();
     if (top_sites)
       top_sites->SyncWithHistory();
   }
 
-  bool use_bundled_frontend_resources_;
   int last_tethering_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsServerDelegate);
 };
 
 }  // namespace
 
 DevToolsServer::DevToolsServer()
-    : use_bundled_frontend_resources_(false),
-      socket_name_(kDefaultSocketName),
+    : socket_name_(base::StringPrintf(kDevToolsChannelNameFormat,
+                                      kDefaultSocketNamePrefix)),
       protocol_handler_(NULL) {
   // Override the default socket name if one is specified on the command line.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kRemoteDebuggingSocketName)) {
     socket_name_ = command_line.GetSwitchValueASCII(
         switches::kRemoteDebuggingSocketName);
   }
 }
 
-DevToolsServer::DevToolsServer(bool use_bundled_frontend_resources,
-                               const std::string& socket_name)
-    : use_bundled_frontend_resources_(use_bundled_frontend_resources),
-      socket_name_(socket_name),
+DevToolsServer::DevToolsServer(const std::string& socket_name_prefix)
+    : socket_name_(base::StringPrintf(kDevToolsChannelNameFormat,
+                                      socket_name_prefix.c_str())),
       protocol_handler_(NULL) {
 }
 
 DevToolsServer::~DevToolsServer() {
   Stop();
 }
 
 void DevToolsServer::Start() {
   if (protocol_handler_)
     return;
 
-  chrome::VersionInfo version_info;
-
   protocol_handler_ = content::DevToolsHttpHandler::Start(
       new net::UnixDomainSocketWithAbstractNamespaceFactory(
           socket_name_,
           base::StringPrintf("%s_%d", socket_name_.c_str(), getpid()),
           base::Bind(&content::CanUserConnectToDevTools)),
-      use_bundled_frontend_resources_ ?
-          "" :
-          base::StringPrintf(kFrontEndURL, version_info.Version().c_str()),
-      new DevToolsServerDelegate(use_bundled_frontend_resources_));
+      base::StringPrintf(kFrontEndURL,
+                         webkit_glue::GetWebKitRevision().c_str()),
+      new DevToolsServerDelegate());
 }
 
 void DevToolsServer::Stop() {
   if (!protocol_handler_)
     return;
   // Note that the call to Stop() below takes care of |protocol_handler_|
   // deletion.
   protocol_handler_->Stop();
   protocol_handler_ = NULL;
 }
 
 bool DevToolsServer::IsStarted() const {
   return protocol_handler_;
 }
 
 bool RegisterDevToolsServer(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 static jint InitRemoteDebugging(JNIEnv* env,
                                 jobject obj,
-                                jboolean use_bundled_frontend_resources,
-                                jstring socketName) {
+                                jstring socketNamePrefix) {

[pfeldman, 2013/06/20 17:03:39]

socket_name_prefix ?

[mnaganov (inactive), 2013/06/21 09:21:45]

Done. Writing JNI code is always challenging when it comes to following coding
conventions.

   DevToolsServer* server = new DevToolsServer(
-      use_bundled_frontend_resources,
-      base::android::ConvertJavaStringToUTF8(env, socketName));
+      base::android::ConvertJavaStringToUTF8(env, socketNamePrefix));
   return reinterpret_cast<jint>(server);
 }
 
 static void DestroyRemoteDebugging(JNIEnv* env, jobject obj, jint server) {
   delete reinterpret_cast<DevToolsServer*>(server);
 }
 
 static jboolean IsRemoteDebuggingEnabled(JNIEnv* env,
                                          jobject obj,
                                          jint server) {
   return reinterpret_cast<DevToolsServer*>(server)->IsStarted();
 }
 
 static void SetRemoteDebuggingEnabled(JNIEnv* env,
                                       jobject obj,
                                       jint server,
                                       jboolean enabled) {
   DevToolsServer* devtools_server = reinterpret_cast<DevToolsServer*>(server);
   if (enabled) {
     devtools_server->Start();
   } else {
     devtools_server->Stop();
   }
 }