DevTools: display 'Pending authentication' message upon raw usb debugging.

chrome/browser/ui/webui/inspect_ui.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/ui/webui/inspect_ui.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 78 matching lines @@
 
 const char kTargetTypeField[]  = "type";
 const char kAttachedField[]  = "attached";
 const char kProcessIdField[]  = "processId";
 const char kRouteIdField[]  = "routeId";
 const char kUrlField[]  = "url";
 const char kNameField[]  = "name";
 const char kFaviconUrlField[] = "faviconUrl";
 const char kDescription[] = "description";
 const char kPidField[]  = "pid";
+const char kAdbConnectedField[] = "adbConnected";
+const char kAdbModelField[] = "adbModel";
 const char kAdbSerialField[] = "adbSerial";
-const char kAdbModelField[] = "adbModel";
 const char kAdbBrowserProductField[] = "adbBrowserProduct";
 const char kAdbBrowserPackageField[] = "adbBrowserPackage";
 const char kAdbBrowserVersionField[] = "adbBrowserVersion";
 const char kAdbGlobalIdField[] = "adbGlobalId";
 const char kAdbBrowsersField[] = "browsers";
 const char kAdbPagesField[] = "pages";
 const char kAdbPortStatus[] = "adbPortStatus";
 const char kAdbScreenWidthField[] = "adbScreenWidth";
 const char kAdbScreenHeightField[] = "adbScreenHeight";
 const char kAdbAttachedForeignField[]  = "adbAttachedForeign";
@@ skipping 571 matching lines @@
     port_forwarding_status =
         port_forwarding_controller->UpdateDeviceList(*devices);
 
   remote_browsers_.clear();
   remote_pages_.clear();
   ListValue device_list;
   for (DevToolsAdbBridge::RemoteDevices::iterator dit = devices->begin();
        dit != devices->end(); ++dit) {
     DevToolsAdbBridge::RemoteDevice* device = dit->get();
     DictionaryValue* device_data = new DictionaryValue();
-    device_data->SetString(kAdbModelField, device->model());
-    device_data->SetString(kAdbSerialField, device->serial());
+    device_data->SetString(kAdbModelField, device->GetModel());
+    device_data->SetString(kAdbSerialField, device->GetSerial());
+    device_data->SetBoolean(kAdbConnectedField, device->IsConnected());
     std::string device_id = base::StringPrintf(
         "device:%s",
-        device->serial().c_str());
+        device->GetSerial().c_str());
     device_data->SetString(kAdbGlobalIdField, device_id);
     ListValue* browser_list = new ListValue();
     device_data->Set(kAdbBrowsersField, browser_list);
 
     DevToolsAdbBridge::RemoteBrowsers& browsers = device->browsers();
     for (DevToolsAdbBridge::RemoteBrowsers::iterator bit =
         browsers.begin(); bit != browsers.end(); ++bit) {
       DevToolsAdbBridge::RemoteBrowser* browser = bit->get();
       DictionaryValue* browser_data = new DictionaryValue();
       browser_data->SetString(kAdbBrowserProductField, browser->product());
       browser_data->SetString(kAdbBrowserPackageField, browser->package());
       browser_data->SetString(kAdbBrowserVersionField, browser->version());
       std::string browser_id = base::StringPrintf(
           "browser:%s:%s:%s",
-          device->serial().c_str(),
+          device->GetSerial().c_str(),
           browser->product().c_str(),  // Force sorting by product name.
           browser->socket().c_str());
       browser_data->SetString(kAdbGlobalIdField, browser_id);
       remote_browsers_[browser_id] = browser;
       ListValue* page_list = new ListValue();
       browser_data->Set(kAdbPagesField, page_list);
 
       DevToolsAdbBridge::RemotePages& pages = browser->pages();
       for (DevToolsAdbBridge::RemotePages::iterator it =
           pages.begin(); it != pages.end(); ++it) {
         DevToolsAdbBridge::RemotePage* page =  it->get();
         DictionaryValue* page_data = BuildTargetDescriptor(
             kAdbTargetType, page->attached(),
             GURL(page->url()), page->title(), GURL(page->favicon_url()),
             page->description(), 0, 0);
         std::string page_id = base::StringPrintf("page:%s:%s:%s",
-            device->serial().c_str(),
+            device->GetSerial().c_str(),
             browser->socket().c_str(),
             page->id().c_str());
         page_data->SetString(kAdbGlobalIdField, page_id);
         page_data->SetBoolean(kAdbAttachedForeignField,
             page->attached() && !page->HasDevToolsWindow());
         // Pass the screen size in the page object to make sure that
         // the caching logic does not prevent the page item from updating
         // when the screen size changes.
-        gfx::Size screen_size = device->GetScreenSize();
+        gfx::Size screen_size = device->screen_size();
         page_data->SetInteger(kAdbScreenWidthField, screen_size.width());
         page_data->SetInteger(kAdbScreenHeightField, screen_size.height());
         remote_pages_[page_id] = page;
         page_list->Append(page_data);
       }
       browser_list->Append(browser_data);
     }
 
     if (port_forwarding_controller) {
       PortForwardingController::DevicesStatus::iterator sit =
-          port_forwarding_status.find(device->serial());
+          port_forwarding_status.find(device->GetSerial());
       if (sit != port_forwarding_status.end()) {
         DictionaryValue* port_status_dict = new DictionaryValue();
         typedef PortForwardingController::PortStatusMap StatusMap;
         const StatusMap& port_status = sit->second;
         for (StatusMap::const_iterator it = port_status.begin();
              it != port_status.end(); ++it) {
           port_status_dict->SetInteger(
               base::StringPrintf("%d", it->first), it->second);
         }
         device_data->Set(kAdbPortStatus, port_status_dict);
@@ skipping 61 matching lines @@
   base::DictionaryValue default_config;
   default_config.SetString(
       kPortForwardingDefaultPort, kPortForwardingDefaultLocation);
   prefs->Set(prefs::kDevToolsPortForwardingConfig, default_config);
 }
 
 const base::Value* InspectUI::GetPrefValue(const char* name) {
   Profile* profile = Profile::FromWebUI(web_ui());
   return profile->GetPrefs()->FindPreference(name)->GetValue();
 }