c++11 ud suffix fixes for cros dbus files

chromeos/network/network_state_handler.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 "chromeos/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/stl_util.h"
@@ skipping 364 matching lines @@
   }
 }
 
 //------------------------------------------------------------------------------
 // ShillPropertyHandler::Delegate overrides
 
 void NetworkStateHandler::UpdateManagedList(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
   ManagedStateList* managed_list = GetManagedList(type);
   NET_LOG_DEBUG(base::StringPrintf("UpdateManagedList:%d", type),
-                base::StringPrintf("%"PRIuS, entries.GetSize()));
+                base::StringPrintf("%" PRIuS, entries.GetSize()));
   // Create a map of existing entries. Assumes all entries in |managed_list|
   // are unique.
   std::map<std::string, ManagedState*> managed_map;
   for (ManagedStateList::iterator iter = managed_list->begin();
        iter != managed_list->end(); ++iter) {
     ManagedState* managed = *iter;
     DCHECK(!ContainsKey(managed_map, managed->path()));
     managed_map[managed->path()] = managed;
   }
   // Clear the list (pointers are temporarily owned by managed_map).
@@ skipping 149 matching lines @@
   NET_LOG_DEBUG("NotifyManagerPropertyChanged", "");
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkManagerChanged());
 }
 
 void NetworkStateHandler::ManagedStateListChanged(
     ManagedState::ManagedType type) {
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     // Notify observers that the list of networks has changed.
     NET_LOG_EVENT("NetworkListChanged",
-                  base::StringPrintf("Size:%"PRIuS, network_list_.size()));
+                  base::StringPrintf("Size:%" PRIuS, network_list_.size()));
     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                       NetworkListChanged());
     // The list order may have changed, so check if the default network changed.
     if (CheckDefaultNetworkChanged())
       OnDefaultNetworkChanged();
   } else if (type == ManagedState::MANAGED_TYPE_FAVORITE) {
     NET_LOG_DEBUG("FavoriteListChanged",
-                  base::StringPrintf("Size:%"PRIuS, favorite_list_.size()));
+                  base::StringPrintf("Size:%" PRIuS, favorite_list_.size()));
     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                       NetworkListChanged());
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     NET_LOG_DEBUG("DeviceListChanged",
-                  base::StringPrintf("Size:%"PRIuS, device_list_.size()));
+                  base::StringPrintf("Size:%" PRIuS, device_list_.size()));
     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                       DeviceListChanged());
   } else {
     NOTREACHED();
   }
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
@@ skipping 83 matching lines @@
     connecting_network_.clear();
     NET_LOG_EVENT("ClearConnectingNetwork", base::StringPrintf(
         "%s:%s", GetManagedStateLogName(network).c_str(),
         network->connection_state().c_str()));
   }
 }
 
 void NetworkStateHandler::ScanCompleted(const std::string& type) {
   size_t num_callbacks = scan_complete_callbacks_.count(type);
   NET_LOG_EVENT("ScanCompleted",
-                base::StringPrintf("%s:%"PRIuS, type.c_str(), num_callbacks));
+                base::StringPrintf("%s:%" PRIuS, type.c_str(), num_callbacks));
   if (num_callbacks == 0)
     return;
   ScanCallbackList& callback_list = scan_complete_callbacks_[type];
   for (ScanCallbackList::iterator iter = callback_list.begin();
        iter != callback_list.end(); ++iter) {
     (*iter).Run();
   }
   scan_complete_callbacks_.erase(type);
 }
 
 std::string NetworkStateHandler::GetTechnologyForType(
     const std::string& type) const {
   if (type == kMatchTypeMobile) {
     if (shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax))
       return flimflam::kTypeWimax;
     else
       return flimflam::kTypeCellular;
   }
   if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
       type == kMatchTypeWireless) {
     NOTREACHED();
     return flimflam::kTypeWifi;
   }
   return type;
 }
 
 }  // namespace chromeos