If requested, report network interfaces to management server.

chrome/browser/chromeos/policy/device_status_collector.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/policy/device_status_collector.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/network/device_state.h"
+#include "chromeos/network/network_handler.h"
+#include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 using base::Time;
 using base::TimeDelta;
 using chromeos::VersionLoader;
 
 namespace em = enterprise_management;
 
@@ skipping 91 matching lines @@
       last_idle_check_(Time()),
       last_reported_day_(0),
       duration_for_last_reported_day_(0),
       geolocation_update_in_progress_(false),
       statistics_provider_(provider),
       weak_factory_(this),
       report_version_info_(false),
       report_activity_times_(false),
       report_boot_mode_(false),
       report_location_(false),
+      report_network_interfaces_(false),
       context_(new Context()) {
   if (location_update_requester) {
     location_update_requester_ = *location_update_requester;
   } else {
     location_update_requester_ =
         base::Bind(&Context::GetLocationUpdate, context_.get());
   }
   idle_poll_timer_.Start(FROM_HERE,
                          TimeDelta::FromSeconds(kIdlePollIntervalSeconds),
                          this, &DeviceStatusCollector::CheckIdleState);
 
   cros_settings_ = chromeos::CrosSettings::Get();
 
   // Watch for changes to the individual policies that control what the status
   // reports contain.
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceVersionInfo, this);
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceActivityTimes,
                                       this);
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceBootMode, this);
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceLocation, this);
+  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceNetworkInterfaces,
+                                      this);
 
   // The last known location is persisted in local state. This makes location
   // information available immediately upon startup and avoids the need to
   // reacquire the location on every user session change or browser crash.
   content::Geoposition position;
   std::string timestamp_str;
   int64 timestamp;
   const base::DictionaryValue* location =
       local_state_->GetDictionary(prefs::kDeviceLocation);
   if (location->GetDouble(kLatitude, &position.latitude) &&
@@ skipping 22 matching lines @@
       &tracker_);
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceVersionInfo,
                                          this);
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceActivityTimes,
                                          this);
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceBootMode, this);
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceLocation, this);
+  cros_settings_->RemoveSettingsObserver(
+      chromeos::kReportDeviceNetworkInterfaces, this);
 }
 
 // static
 void DeviceStatusCollector::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kDeviceActivityTimes,
                                    new base::DictionaryValue);
   registry->RegisterDictionaryPref(prefs::kDeviceLocation,
                                    new base::DictionaryValue);
 }
 
@@ skipping 14 matching lines @@
     return;
   }
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceVersionInfo, &report_version_info_);
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceActivityTimes, &report_activity_times_);
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceBootMode, &report_boot_mode_);
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceLocation, &report_location_);
+  cros_settings_->GetBoolean(
+      chromeos::kReportDeviceNetworkInterfaces, &report_network_interfaces_);
 
   if (report_location_) {
     ScheduleGeolocationUpdateRequest();
   } else {
     geolocation_update_timer_.Stop();
     position_ = content::Geoposition();
     local_state_->ClearPref(prefs::kDeviceLocation);
   }
 }
 
@@ skipping 155 matching lines @@
     if (position_.altitude_accuracy >= 0.)
       location->set_altitude_accuracy(position_.altitude_accuracy);
     if (position_.heading >= 0. && position_.heading <= 360)
       location->set_heading(position_.heading);
     if (position_.speed >= 0.)
       location->set_speed(position_.speed);
     location->set_error_code(em::DeviceLocation::ERROR_CODE_NONE);
   }
 }
 
+void DeviceStatusCollector::GetNetworkInterfaces(
+    em::DeviceStatusReportRequest* request) {
+  chromeos::NetworkStateHandler::DeviceStateList device_list;
+  chromeos::NetworkHandler::Get()->network_state_handler()->GetDeviceList(
+      &device_list);
+
+  chromeos::NetworkStateHandler::DeviceStateList::const_iterator device;

[pneubeck (no reviews), 2013/07/04 15:51:48]

nit:
alternatively, typedef chromeos::NetworkStateHandler::DeviceStateList locally
and declare 'device' inside the 'for'.

[Mattias Nissler (ping if slow), 2013/07/11 17:41:46]

I only need the type once, and I'd have to break the loop declaration line, so
no.

[pneubeck (no reviews), 2013/07/11 18:49:31]

FWIW, chromeos::NetworkStateHandler::DeviceStateList is used twice, not once.

[Mattias Nissler (ping if slow), 2013/07/12 08:11:55]

Oh right, I misread your comment to typedef the iterator. In any case, this
version is more readable than the typedef version IMHO.

+  for (device = device_list.begin(); device != device_list.end(); ++device) {
+    em::NetworkInterface* interface = request->add_network_interface();
+    if ((*device)->type().empty())
+      continue;

[pneubeck (no reviews), 2013/07/04 15:51:48]

in this case, an empty NetworkInterface would have been added.
Is that useful?

[Mattias Nissler (ping if slow), 2013/07/11 17:41:46]

I don't think so, hence I skip this case. The updated code now filters for types
that are actually relevant. In particular, VPN devices don't really make sense
to be reported to the server as they don't have hardware addresses.

+
+    interface->set_type((*device)->type());
+    if (!(*device)->mac_address().empty())
+      interface->set_mac_address((*device)->mac_address());
+    if (!(*device)->meid().empty())
+      interface->set_meid((*device)->meid());
+  }
+}
+
 void DeviceStatusCollector::GetStatus(em::DeviceStatusReportRequest* request) {
   // TODO(mnissler): Remove once the old cloud policy stack is retired. The old
   // stack doesn't support reporting successful submissions back to here, so
   // just assume whatever ends up in |request| gets submitted successfully.
   GetDeviceStatus(request);
   OnSubmittedSuccessfully();
 }
 
 bool DeviceStatusCollector::GetDeviceStatus(
     em::DeviceStatusReportRequest* status) {
   if (report_activity_times_)
     GetActivityTimes(status);
 
   if (report_version_info_)
     GetVersionInfo(status);
 
   if (report_boot_mode_)
     GetBootMode(status);
 
   if (report_location_)
     GetLocation(status);
 
+  if (report_network_interfaces_)
+    GetNetworkInterfaces(status);
+
   return true;
 }
 
 bool DeviceStatusCollector::GetSessionStatus(
     em::SessionStatusReportRequest* status) {
   return false;
 }
 
 void DeviceStatusCollector::OnSubmittedSuccessfully() {
   TrimStoredActivityPeriods(last_reported_day_, duration_for_last_reported_day_,
@@ skipping 66 matching lines @@
     location.SetDouble(kSpeed, position.speed);
     location.SetString(kTimestamp,
         base::Int64ToString(position.timestamp.ToInternalValue()));
     local_state_->Set(prefs::kDeviceLocation, location);
   }
 
   ScheduleGeolocationUpdateRequest();
 }
 
 }  // namespace policy