Provide Shill IP Address to myIpAddress()

chrome/browser/chromeos/proxy_config_service_impl.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/chromeos/proxy_config_service_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 143 matching lines @@
   }
 
   // This network is shared and not managed by the user's domain.
   bool use_shared_proxies = profile_prefs->GetBoolean(prefs::kUseSharedProxies);
   VLOG(1) << "Use proxy of shared network: " << use_shared_proxies;
   return !use_shared_proxies;
 }
 
 void ProxyConfigServiceImpl::DetermineEffectiveConfigFromDefaultNetwork() {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
-  const FavoriteState* network = handler->DefaultFavoriteNetwork();
+  const FavoriteState* favorite = handler->DefaultFavoriteNetwork();
 
   // Get prefs proxy config if available.
   net::ProxyConfig pref_config;
   ProxyPrefs::ConfigState pref_state = GetProxyConfig(&pref_config);
 
   // Get network proxy config if available.
   net::ProxyConfig network_config;
   net::ProxyConfigService::ConfigAvailability network_availability =
       net::ProxyConfigService::CONFIG_UNSET;
   bool ignore_proxy = true;
-  if (network) {
+  if (favorite) {
     ::onc::ONCSource onc_source = ::onc::ONC_SOURCE_NONE;
     const bool network_proxy_configured = chromeos::GetProxyConfig(
-        prefs(), local_state_prefs_, *network, &network_config, &onc_source);
+        prefs(), local_state_prefs_, *favorite, &network_config, &onc_source);
     ignore_proxy =
-        IgnoreProxy(profile_prefs_, network->profile_path(), onc_source);
+        IgnoreProxy(profile_prefs_, favorite->profile_path(), onc_source);
 
-    // If network is shared but use-shared-proxies is off, use direct mode.
+    // If favorite is shared but use-shared-proxies is off, use direct mode.
     if (ignore_proxy) {
       network_config = net::ProxyConfig();
       network_availability = net::ProxyConfigService::CONFIG_VALID;
     } else if (network_proxy_configured) {
       // Network is private or shared with user using shared proxies.
-      VLOG(1) << this << ": using proxy of network " << network->path();
+      VLOG(1) << this << ": using proxy of network " << favorite->path();
       network_availability = net::ProxyConfigService::CONFIG_VALID;
     }
   }
 
   // Determine effective proxy config, either from prefs or network.
   ProxyPrefs::ConfigState effective_config_state;
   net::ProxyConfig effective_config;
   GetEffectiveProxyConfig(pref_state, pref_config,
                           network_availability, network_config, ignore_proxy,
                           &effective_config_state, &effective_config);
+  if (favorite) {
+    const NetworkState* network = handler->GetNetworkState(favorite->path());
+    if (network)
+      effective_config.set_my_ip_address(network->ip_address());
+  }
 
   // Activate effective proxy and store into |active_config_|.
   // If last update didn't complete, we definitely update now.
   bool update_now = update_pending();
   if (!update_now) {  // Otherwise, only update now if there're changes.
     update_now = active_config_state_ != effective_config_state ||
                  (active_config_state_ != ProxyPrefs::CONFIG_UNSET &&
                   !active_config_.Equals(effective_config));
   }
   if (update_now) {  // Activate and store new effective config.
@@ skipping 16 matching lines @@
     if (VLOG_IS_ON(1) && !update_pending()) {  // Update was successful.
       scoped_ptr<base::DictionaryValue> config_dict(effective_config.ToValue());
       VLOG(1) << this << ": Proxy changed: "
               << ProxyPrefs::ConfigStateToDebugString(active_config_state_)
               << ", " << *config_dict;
     }
   }
 }
 
 }  // namespace chromeos