Fix Telemetry.

chrome/browser/devtools/port_forwarding_controller.cc

 // Copyright 2013 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/port_forwarding_controller.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 31 matching lines @@
   kStatusOK = 0,
   // Positive values are used to count open connections.
 };
 
 static const char kPortAttribute[] = "port";
 static const char kConnectionIdAttribute[] = "connectionId";
 static const char kTetheringAccepted[] = "Tethering.accepted";
 static const char kTetheringBind[] = "Tethering.bind";
 static const char kTetheringUnbind[] = "Tethering.unbind";
 
+static const char kChromeProductName[] = "Chrome";
 static const char kDevToolsRemoteBrowserTarget[] = "/devtools/browser";
 const int kMinVersionPortForwarding = 28;
 
 class SocketTunnel {
  public:
   typedef base::Callback<void(int)> CounterCallback;
 
   SocketTunnel(const std::string& location, const CounterCallback& callback)
       : location_(location),
         pending_writes_(0),
@@ skipping 151 matching lines @@
   scoped_ptr<net::StreamSocket> remote_socket_;
   scoped_ptr<net::StreamSocket> host_socket_;
   scoped_ptr<net::HostResolver> host_resolver_;
   net::AddressList address_list_;
   int pending_writes_;
   bool pending_destruction_;
   CounterCallback callback_;
   bool about_to_destroy_;
 };
 
-typedef DevToolsAdbBridge::RemoteBrowser::ParsedVersion ParsedVersion;
+typedef std::vector<int> ParsedVersion;
+
+static ParsedVersion ParseVersion(const std::string& version) {
+  ParsedVersion result;
+  std::vector<std::string> parts;
+  Tokenize(version, ".", &parts);
+  for (size_t i = 0; i != parts.size(); ++i) {
+    int value = 0;
+    base::StringToInt(parts[i], &value);
+    result.push_back(value);
+  }
+  return result;
+}
 
 static bool IsVersionLower(const ParsedVersion& left,
                            const ParsedVersion& right) {
   return std::lexicographical_compare(
     left.begin(), left.end(), right.begin(), right.end());
 }
 
 static bool IsPortForwardingSupported(const ParsedVersion& version) {
   return !version.empty() && version[0] >= kMinVersionPortForwarding;
 }
 
 static std::string FindBestSocketForTethering(
     const DevToolsAdbBridge::RemoteBrowsers browsers) {
   std::string socket;
   ParsedVersion newest_version;
   for (DevToolsAdbBridge::RemoteBrowsers::const_iterator it = browsers.begin();
        it != browsers.end(); ++it) {
     scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser = *it;
-    ParsedVersion current_version = browser->GetParsedVersion();
-    if (browser->IsChrome() &&
+    ParsedVersion current_version = ParseVersion(browser->version());
+    if (browser->product() == kChromeProductName &&
         IsPortForwardingSupported(current_version) &&
         IsVersionLower(newest_version, current_version)) {
       socket = browser->socket();
       newest_version = current_version;
     }
   }
   return socket;
 }
 
 }  // namespace
@@ skipping 364 matching lines @@
           BrowserContextDependencyManager::GetInstance()) {}
 
 PortForwardingController::Factory::~Factory() {}
 
 BrowserContextKeyedService*
 PortForwardingController::Factory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   Profile* profile = Profile::FromBrowserContext(context);
   return new PortForwardingController(profile->GetPrefs());
 }