Cleanup: Remove some unused code, or make them platform specific.

chrome/browser/devtools/devtools_adb_bridge.cc

 // Copyright (c) 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/devtools_adb_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 280 matching lines @@
   scoped_ptr<DevToolsAdbBridge::RemoteDevices> remote_devices_;
   DevToolsAdbBridge::DeviceProviders device_providers_;
 };
 
 AdbPagesCommand::AdbPagesCommand(
     scoped_refptr<RefCountedAdbThread> adb_thread,
     const DevToolsAdbBridge::DeviceProviders& device_providers,
     const Callback& callback)
     : adb_thread_(adb_thread),
       callback_(callback),
-      device_providers_(device_providers){
+      device_providers_(device_providers) {
   remote_devices_.reset(new DevToolsAdbBridge::RemoteDevices());
 
   ProcessDeviceProviders();
 }
 
 AdbPagesCommand::~AdbPagesCommand() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void AdbPagesCommand::ProcessDeviceProviders() {
@@ skipping 411 matching lines @@
     content::BrowserContext* context) const {
   return new DevToolsAdbBridge::Wrapper();
 }
 
 
 // AgentHostDelegate ----------------------------------------------------------
 
 class AgentHostDelegate : public content::DevToolsExternalAgentProxyDelegate,
                           public AdbWebSocket::Delegate {
  public:
-   static void Create(const std::string& id,
-                      scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
-                      const std::string& debug_url,
-                      const std::string& frontend_url,
-                      Profile* profile) {
+  static void Create(const std::string& id,
+                     scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
+                     const std::string& debug_url,
+                     const std::string& frontend_url,
+                     Profile* profile) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     AgentHostDelegates::iterator it =
         g_host_delegates.Get().find(id);
     if (it != g_host_delegates.Get().end()) {
       it->second->OpenFrontend();
     } else if (!frontend_url.empty()) {
       new AgentHostDelegate(
           id, browser->device(), browser->socket(), debug_url,
           frontend_url, browser->adb_thread()->message_loop(), profile);
     }
   }
 
  private:
   AgentHostDelegate(
       const std::string& id,
       scoped_refptr<AndroidDevice> device,
       const std::string& socket_name,
       const std::string& debug_url,
       const std::string& frontend_url,
       base::MessageLoop* adb_message_loop,
       Profile* profile)
       : id_(id),
         frontend_url_(frontend_url),
-        adb_message_loop_(adb_message_loop),
         profile_(profile) {
     web_socket_ = new AdbWebSocket(
         device, socket_name, debug_url, adb_message_loop, this);
     g_host_delegates.Get()[id] = this;
 
     if (socket_name.find(kWebViewSocketPrefix) == 0) {
       content::RecordAction(
           base::UserMetricsAction("DevTools_InspectAndroidWebView"));
     } else {
       content::RecordAction(
@@ skipping 36 matching lines @@
       proxy_->ConnectionClosed();
     delete this;
   }
 
   virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE {
     return false;
   }
 
   const std::string id_;
   const std::string frontend_url_;
-  base::MessageLoop* adb_message_loop_;
   Profile* profile_;
 
   scoped_ptr<content::DevToolsExternalAgentProxy> proxy_;
   scoped_refptr<AdbWebSocket> web_socket_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
 //// RemotePageTarget ----------------------------------------------
 
 class RemotePageTarget : public DevToolsTargetImpl {
@@ skipping 313 matching lines @@
 
   if (listeners_.empty())
     return;
 
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }