[DevTools] Remove support for old /json/new

chrome/browser/devtools/device/devtools_android_bridge.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 "chrome/browser/devtools/device/devtools_android_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 35 matching lines @@
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kPageListRequest[] = "/json";
 const char kVersionRequest[] = "/json/version";
 const char kClosePageRequest[] = "/json/close/%s";
-const char kNewPageRequest[] = "/json/new";
 const char kNewPageRequestWithURL[] = "/json/new?%s";
 const char kActivatePageRequest[] = "/json/activate/%s";
 const char kBrowserTargetSocket[] = "/devtools/browser";
 const int kAdbPollingIntervalMs = 1000;
 
-const char kUrlParam[] = "url";
 const char kPageReloadCommand[] = "Page.reload";
-const char kPageNavigateCommand[] = "Page.navigate";
-
-const int kMinVersionNewWithURL = 32;
-const int kNewPageNavigateDelayMs = 500;
 
 const char kWebViewSocketPrefix[] = "webview_devtools_remote";
 
 bool IsWebRTCDeviceProviderEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableDevToolsExperiments);
 }
 
 bool BrowserIdFromString(const std::string& browser_id_str,
                          DevToolsAndroidBridge::BrowserId* browser_id) {
@@ skipping 359 matching lines @@
   ~RemotePageTarget() override;
 
   // DevToolsTargetImpl overrides.
   std::string GetId() const override;
   bool IsAttached() const override;
   bool Activate() const override;
   bool Close() const override;
   void Inspect(Profile* profile) const override;
   void Reload() const override;
 
-  void Navigate(const std::string& url, base::Closure callback) const;
-
  private:
   base::WeakPtr<DevToolsAndroidBridge> bridge_;
   BrowserId browser_id_;
   std::string debug_url_;
   std::string frontend_url_;
   std::string remote_id_;
   std::string remote_type_;
   std::string local_id_;
   DISALLOW_COPY_AND_ASSIGN(RemotePageTarget);
 };
@@ skipping 99 matching lines @@
 }
 
 void DevToolsAndroidBridge::RemotePageTarget::Reload() const {
   if (!bridge_)
     return;
 
   bridge_->SendProtocolCommand(browser_id_, debug_url_, kPageReloadCommand,
                                NULL, base::Closure());
 }
 
-void DevToolsAndroidBridge::RemotePageTarget::Navigate(
-    const std::string& url,
-    base::Closure callback) const {
-  if (!bridge_)
-    return;
-
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue);
-  params->SetString(kUrlParam, url);
-  bridge_->SendProtocolCommand(browser_id_, debug_url_, kPageNavigateCommand,
-                               params.Pass(), callback);
-}
-
 // DevToolsAndroidBridge::RemotePage ------------------------------------------
 
 DevToolsAndroidBridge::RemotePage::RemotePage(const BrowserId& browser_id,
                                               const base::DictionaryValue& dict)
     : browser_id_(browser_id),
       frontend_url_(GetFrontendURL(dict)),
       dict_(dict.DeepCopy()) {
 }
 
 DevToolsAndroidBridge::RemotePage::~RemotePage() {
@@ skipping 121 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GURL gurl(input_url);
   if (!gurl.is_valid()) {
     gurl = GURL("http://" + input_url);
     if (!gurl.is_valid())
       return;
   }
   std::string url = gurl.spec();
   RemoteBrowser::ParsedVersion parsed_version = browser->GetParsedVersion();
 
-  if (browser->IsChrome() &&
-      !parsed_version.empty() &&
-      parsed_version[0] >= kMinVersionNewWithURL) {
-    std::string query = net::EscapeQueryParamValue(url, false /* use_plus */);
-    std::string request =
-        base::StringPrintf(kNewPageRequestWithURL, query.c_str());
-    SendJsonRequest(browser->browser_id_, request,
-                    base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
-                               AsWeakPtr(), browser, callback));
-  } else {
-    SendJsonRequest(browser->browser_id_, kNewPageRequest,
-                    base::Bind(&DevToolsAndroidBridge::PageCreatedOnUIThread,
-                               AsWeakPtr(), browser, callback, url));
-  }
-}
-
-void DevToolsAndroidBridge::PageCreatedOnUIThread(
-    scoped_refptr<RemoteBrowser> browser,
-    const RemotePageCallback& callback,
-    const std::string& url,
-    int result,
-    const std::string& response) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  if (result < 0)
-    return;
-  // Navigating too soon after the page creation breaks navigation history
-  // (crbug.com/311014). This can be avoided by adding a moderate delay.
-  BrowserThread::PostDelayedTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&DevToolsAndroidBridge::NavigatePageOnUIThread,
-                 AsWeakPtr(), browser, callback, result, response, url),
-      base::TimeDelta::FromMilliseconds(kNewPageNavigateDelayMs));
-}
-
-void DevToolsAndroidBridge::NavigatePageOnUIThread(
-    scoped_refptr<RemoteBrowser> browser,
-    const RemotePageCallback& callback,
-    int result,
-    const std::string& response,
-    const std::string& url) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  scoped_ptr<base::Value> value(base::JSONReader::Read(response));
-  base::DictionaryValue* dict;
-
-  if (value && value->GetAsDictionary(&dict)) {
-    RemotePageTarget new_page(this, browser->browser_id_, *dict);
-    new_page.Navigate(url,
-        base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
-                   AsWeakPtr(), browser, callback, result, response));
-  }
+  std::string query = net::EscapeQueryParamValue(url, false /* use_plus */);
+  std::string request =
+      base::StringPrintf(kNewPageRequestWithURL, query.c_str());
+  SendJsonRequest(browser->browser_id_, request,
+                  base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
+                             AsWeakPtr(), browser, callback));
 }
 
 DevToolsAndroidBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
 // DevToolsAndroidBridge::RemoteDevice ----------------------------------------
 
 DevToolsAndroidBridge::RemoteDevice::RemoteDevice(
     const std::string& serial,
     const AndroidDeviceManager::DeviceInfo& device_info)
@@ skipping 230 matching lines @@
     device_providers.push_back(
         new WebRTCDeviceProvider(profile_, signin_manager_, token_service_));
   }
 
   device_manager_->SetDeviceProviders(device_providers);
   if (NeedsDeviceListPolling()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }