diff --git a/mobile_operator.cc b/mobile_operator.cc
deleted file mode 100644
index 189189a..0000000
--- a/mobile_operator.cc
+++ /dev/null
@@ -1,330 +0,0 @@
-// Copyright (c) 2013 The Chromium OS 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 "shill/mobile_operator.h"
-
-#include <vector>
-
-#include <base/stl_util.h>
-#include <chromeos/dbus/service_constants.h>
-#include <mobile_provider.h>
-
-#include "shill/cellular_operator_info.h"
-#include "shill/logging.h"
-#include "shill/modem_info.h"
-
-using std::string;
-using std::vector;
-
-namespace shill {
-
-namespace {
-
-const char kCodeKey[] = "code";
-const char kCountryKey[] = "country";
-const char kNameKey[] = "name";
-
-bool CompareStringmapValue(const Stringmap &dict, const string &key,
-                           const string &value) {
-  if (!ContainsKey(dict, key))
-    return value.empty();
-  return dict.find(key)->second == value;
-}
-
-const CellularOperatorInfo::CellularOperator *LookupCellularOperatorInfo(
-    shill::ModemInfo *modem_info, const string &code,
-    MobileOperator::OperatorCodeType type) {
-  if (type == MobileOperator::kOperatorCodeTypeMCCMNC)
-    return modem_info->cellular_operator_info()->
-        GetCellularOperatorByMCCMNC(code);
-  if (type == MobileOperator::kOperatorCodeTypeSID)
-    return modem_info->cellular_operator_info()->
-        GetCellularOperatorBySID(code);
-  return nullptr;
-}
-
-mobile_provider *LookupMobileProviderDB(
-    shill::ModemInfo *modem_info, const string &code, const string &name,
-    MobileOperator::OperatorCodeType type) {
-  if (type != MobileOperator::kOperatorCodeTypeMCCMNC)
-    return nullptr;
-  return mobile_provider_lookup_best_match(
-      modem_info->provider_db(), name.c_str(), code.c_str());
-}
-
-bool AssignDictData(const Stringmap &from, const vector<string> &keys,
-                    Stringmap *to) {
-  bool contents_changed = false;
-  for (const string &key : keys) {
-    string value;
-    if (ContainsKey(from, key))
-      value = from.find(key)->second;
-    if (!CompareStringmapValue(*to, key, value)) {
-      contents_changed = true;
-      if (value.empty())
-        to->erase(key);
-      else
-        (*to)[key] = value;
-    }
-  }
-  return contents_changed;
-}
-
-bool AssignOperatorData(const Stringmap &from, Stringmap *to) {
-  vector<string> keys = { kCodeKey, kNameKey, kCountryKey };
-  return AssignDictData(from, keys, to);
-}
-
-bool AssignOlpData(const Stringmap &from, Stringmap *to) {
-  vector<string> keys = { "url", "method", "postdata" };
-  return AssignDictData(from, keys, to);
-}
-
-Stringmaps BuildApnListFromCellularOperatorInfoResult(
-    const CellularOperatorInfo::CellularOperator *info) {
-  Stringmaps apn_list;
-  for (const CellularOperatorInfo::MobileAPN *apn : info->apn_list().get()) {
-    Stringmap apn_dict;
-    if (!apn->apn.empty())
-      apn_dict[shill::kApnProperty] = apn->apn;
-    if (!apn->username.empty())
-      apn_dict[shill::kApnUsernameProperty] = apn->username;
-    if (!apn->password.empty())
-      apn_dict[shill::kApnPasswordProperty] = apn->password;
-    string lname, lang, name;
-    for (const CellularOperatorInfo::LocalizedName &apn_name :
-            apn->name_list) {
-      if (!apn_name.language.empty()) {
-        if (lname.empty()) {
-          lname = apn_name.name;
-          lang = apn_name.language;
-        }
-      } else if (name.empty()) {
-        name = apn_name.name;
-      }
-    }
-    if (!name.empty())
-      apn_dict[shill::kApnNameProperty] = name;
-    if (!lname.empty()) {
-      apn_dict[shill::kApnLocalizedNameProperty] = lname;
-      apn_dict[shill::kApnLanguageProperty] = lang;
-    }
-    apn_list.push_back(apn_dict);
-  }
-  return apn_list;
-}
-
-Stringmaps BuildApnListFromMobileProviderDbResult(mobile_provider *provider) {
-  Stringmaps apn_list;
-  for (int i = 0; i < provider->num_apns; ++i) {
-    Stringmap apn_dict;
-    mobile_apn *apn = provider->apns[i];
-    if (apn->value)
-      apn_dict[shill::kApnProperty] = apn->value;
-    if (apn->username)
-      apn_dict[shill::kApnUsernameProperty] = apn->username;
-    if (apn->password)
-      apn_dict[shill::kApnPasswordProperty] = apn->password;
-    const localized_name *lname = NULL;
-    const localized_name *name = NULL;
-    for (int j = 0; j < apn->num_names; ++j) {
-      if (apn->names[j]->lang) {
-        if (!lname) {
-          lname = apn->names[j];
-        }
-      } else if (!name) {
-        name = apn->names[j];
-      }
-    }
-    if (name) {
-      apn_dict[kApnNameProperty] = name->name;
-    }
-    if (lname) {
-      apn_dict[kApnLocalizedNameProperty] = lname->name;
-      apn_dict[kApnLanguageProperty] = lname->lang;
-    }
-    apn_list.push_back(apn_dict);
-  }
-  return apn_list;
-}
-
-struct LookupResult {
-  // |operator_data| contains the following keys:
-  //
-  //    kNameKey: The name of the operator,
-  //    kCodeKey: The operator code,
-  //    kCountryKey: Country code,
-  //
-  // Any of the above keys may not be present in the returned dictionary, if a
-  // matching value was not found.
-  Stringmap operator_data;
-  bool requires_roaming;
-  Stringmaps apn_list;
-};
-
-// Finds the best match for the given data based on CellularOperatorInfo and
-// mobile_provider_db. If |get_apns| is true, an APN list will be constructed
-// if a carrier is found. If no match is found in the database, the kNameKey
-// and kCodeKey keys for |operator_data| of the return value will be set to
-// |operator_name| and |operator_code|, respectively.
-LookupResult FindMatchingOperatorResult(shill::ModemInfo *modem_info,
-                                        const string &operator_code,
-                                        const string &operator_name,
-                                        MobileOperator::OperatorCodeType type,
-                                        bool get_apns) {
-  LookupResult result;
-  // First look up in CellularOperatorInfo.
-  const CellularOperatorInfo::CellularOperator *info =
-      LookupCellularOperatorInfo(modem_info, operator_code, type);
-  if (info) {
-    // Match found, depend on information from here.
-    SLOG(Cellular, 3) << "Found match for operator code " << operator_code
-                      << "in CellularOperatorInfo.";
-    result.operator_data[kCodeKey] = operator_code;
-    if (!operator_name.empty())
-      result.operator_data[kNameKey] = operator_name;
-    else if (!info->name_list().empty())
-      result.operator_data[kNameKey] = info->name_list()[0].name;
-    result.operator_data[kCountryKey] = info->country();
-    result.requires_roaming = false;
-
-    // Build APN list if requested.
-    if (get_apns)
-      result.apn_list = BuildApnListFromCellularOperatorInfoResult(info);
-    return result;
-  }
-  // Look up mobile_provider_db.
-  mobile_provider *provider = LookupMobileProviderDB(
-      modem_info, operator_code, operator_name, type);
-  if (provider) {
-    SLOG(Cellular, 3) << "Found match for operator code " << operator_code
-                      << "in mobile_provider_db.";
-    // mobile_provider_db look up works using both |code| and |name|. If no
-    // operator code was provided, use what was returned from the database.
-    if (!operator_code.empty())
-      result.operator_data[kCodeKey] = operator_code;
-    else if (provider->networks && provider->networks[0])
-      result.operator_data[kCodeKey] = provider->networks[0];
-    if (provider->country)
-      result.operator_data[kCountryKey] = provider->country;
-    if (!operator_name.empty())
-      result.operator_data[kNameKey] = operator_name;
-    else {
-      const gchar *name = mobile_provider_get_name(provider);
-      if (name)
-        result.operator_data[kNameKey] = name;
-    }
-    result.requires_roaming = provider->requires_roaming;
-
-    // Build APN list if requested.
-    if (get_apns)
-      result.apn_list = BuildApnListFromMobileProviderDbResult(provider);
-    return result;
-  }
-  SLOG(Cellular, 3) << "No match found for operator code "
-                    << operator_code << ".";
-  if (!operator_code.empty())
-    result.operator_data[kCodeKey] = operator_code;
-  if (!operator_name.empty())
-    result.operator_data[kNameKey] = operator_name;
-  return result;
-}
-
-}  // namespace
-
-MobileOperator::MobileOperator(ModemInfo *modem_info)
-    : modem_info_(modem_info),
-      home_provider_requires_roaming_(false) {}
-
-void MobileOperator::AddObserver(Observer *observer) {
-  observers_.AddObserver(observer);
-}
-
-void MobileOperator::RemoveObserver(Observer *observer) {
-  observers_.RemoveObserver(observer);
-}
-
-void MobileOperator::SimOperatorInfoReceived(const string &operator_code,
-                                             const string &operator_name) {
-  if (operator_code.empty() && operator_name.empty()) {
-    // Clear the home provider.
-    if (!home_provider_.empty()) {
-      home_provider_.clear();
-      NotifyHomeProviderInfoChanged();
-    }
-    return;
-  }
-  LookupResult result = FindMatchingOperatorResult(
-      modem_info_, operator_code, operator_name,
-      kOperatorCodeTypeMCCMNC, false);
-  home_provider_requires_roaming_ = result.requires_roaming;
-  if (AssignOperatorData(result.operator_data, &home_provider_))
-    NotifyHomeProviderInfoChanged();
-}
-
-void MobileOperator::OtaOperatorInfoReceived(const string &operator_code,
-                                             const string &operator_name,
-                                             OperatorCodeType type) {
-  if (operator_code.empty() && operator_name.empty()) {
-    apn_list_.clear();
-    online_payment_url_template_.clear();
-    if (!serving_operator_.empty()) {
-      serving_operator_.clear();
-      NotifyServingOperatorInfoChanged();
-    }
-    return;
-  }
-
-  // Look up the operator and assign it to |serving_operator_|.
-  LookupResult result = FindMatchingOperatorResult(
-      modem_info_, operator_code, operator_name, type, true);
-  bool serving_operator_changed =
-      AssignOperatorData(result.operator_data, &serving_operator_);
-
-  // For now, always notify that APNList changed, as long as the constructed
-  // list is non-empty.
-  if (!apn_list_.empty() || !result.apn_list.empty()) {
-    apn_list_ = result.apn_list;
-    NotifyApnListChanged();
-  }
-
-  // Update the OLP. Notify observers if OLP changed.
-  const CellularService::OLP *olp_result = NULL;
-  if (type == kOperatorCodeTypeMCCMNC) {
-    olp_result = modem_info_->cellular_operator_info()->
-        GetOLPByMCCMNC(operator_code);
-  } else {
-    olp_result = modem_info_->cellular_operator_info()->
-        GetOLPBySID(operator_code);
-  }
-  if (olp_result) {
-    Stringmap olp_dict = olp_result->ToDict();
-    if (AssignOlpData(olp_dict, &online_payment_url_template_))
-      NotifyOnlinePaymentUrlTemplateChanged();
-  } else if (!online_payment_url_template_.empty()) {
-    online_payment_url_template_.clear();
-    NotifyOnlinePaymentUrlTemplateChanged();
-  }
-  if (serving_operator_changed)
-    NotifyServingOperatorInfoChanged();
-}
-
-void MobileOperator::NotifyHomeProviderInfoChanged() {
-  FOR_EACH_OBSERVER(Observer, observers_, OnHomeProviderInfoChanged(this));
-}
-
-void MobileOperator::NotifyServingOperatorInfoChanged() {
-  FOR_EACH_OBSERVER(Observer, observers_, OnServingOperatorInfoChanged(this));
-}
-
-void MobileOperator::NotifyApnListChanged() {
-  FOR_EACH_OBSERVER(Observer, observers_, OnApnListChanged(this));
-}
-
-void MobileOperator::NotifyOnlinePaymentUrlTemplateChanged() {
-  FOR_EACH_OBSERVER(
-      Observer, observers_, OnOnlinePaymentUrlTemplateChanged(this));
-}
-
-}  // namespace shill
diff --git a/mobile_operator.h b/mobile_operator.h
deleted file mode 100644
index cf2ad2c..0000000
--- a/mobile_operator.h
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SHILL_MOBILE_OPERATOR_H_
-#define SHILL_MOBILE_OPERATOR_H_
-
-#include <string>
-
-#include <base/observer_list.h>
-
-#include "shill/accessor_interface.h"
-
-namespace shill {
-
-class ModemInfo;
-
-// MobileOperator contains information related to the current cellular
-// carrier based on data read from the Modem and provides a common place to
-// access this information from.
-class MobileOperator {
- public:
-  enum OperatorCodeType {
-    kOperatorCodeTypeSID,
-    kOperatorCodeTypeMCCMNC
-  };
-
-  // Observer interface used to notify interested classes that data has been
-  // updated.
-  class Observer {
-   public:
-    virtual void OnHomeProviderInfoChanged(const MobileOperator *handler) = 0;
-    virtual void OnServingOperatorInfoChanged(
-        const MobileOperator *handler) = 0;
-    virtual void OnApnListChanged(const MobileOperator *handler) = 0;
-    virtual void OnOnlinePaymentUrlTemplateChanged(
-        const MobileOperator *handler) = 0;
-  };
-
-  explicit MobileOperator(ModemInfo *modem_info);
-
-  // Add/remove observers to subscribe to notifications.
-  void AddObserver(Observer *observer);
-  void RemoveObserver(Observer *observer);
-
-  // This should be called, when operator data is received OTA. The result of
-  // this operation dictates the serving operator, APN list and the online
-  // payment URL. This method will do its best to fill in the operator
-  // information from the databases.
-  //
-  // If |operator_code| is missing, and no best match is found based on
-  // |operator_name|, the contents of the serving operator will be cleared. If
-  // neither |operator_code| nor |operator_name| match an entry in the
-  // databases, the serving operator will be updated based on these arguments.
-  void OtaOperatorInfoReceived(const std::string &operator_code,
-                               const std::string &operator_name,
-                               OperatorCodeType type);
-
-  // This should be called, when operator data is received from the SIM card.
-  // The result of this operation dictates the home provider.
-  //
-  // If |operator_code| is missing, and no best match is found based on
-  // |operator_name|, the contents of the home provider will be cleared. If
-  // neither |operator_code| nor |operator_name| match an entry in the
-  // databases, the home provider will be updated based on these arguments.
-  //
-  // For this method, |operator_code| is always in the MCCMNC format, as SIMs
-  // don't report SIDs. If an SID is passed for |operator_code|, the method
-  // will interpret it as an MCCMNC value.
-  void SimOperatorInfoReceived(const std::string &operator_code,
-                               const std::string &operator_name);
-
-  // Provider information. A user's home provider is the carrier they purchased
-  // their data plan from, whereas the serving operator is the current cellular
-  // operator that is feeding their data. These two are usually the same,
-  // except in the cases of roaming and CDMA. The format of the returned
-  // dictionary is:
-  //    {
-  //      "name": <operator-name>,
-  //      "code": <operator-code>,
-  //      "country": <operator-country>
-  //    }
-  // The keys correspond to shill::kOperatorNameKey, shill::kOperatorCodeKey,
-  // and shill::kOperatorCountryKey respectively, as defined in
-  // service_constants.h. If any of the above keys is not known, there will be
-  // no entry in the dictionary for it.
-  const Stringmap &home_provider() const { return home_provider_; }
-  const Stringmap &serving_operator() const { return serving_operator_; }
-
-  // Known access points related to the current serving operator. Possible keys
-  // are defined in service_constants.h as shill::kApn*.
-  const Stringmaps &apn_list() const { return apn_list_; }
-
-  // The online payment URL, when available, is used by Chrome to access the
-  // carrier's service activation portal it is only available for select
-  // carriers. Possible keys are:
-  //    {
-  //      "url": <the url>,
-  //      "method": <HTTP method>,
-  //      "postdata": <argument template for the url>
-  //    }
-  // The argument template is used to construct the POST arguments for the URL
-  // using information such as ICCID, IMEI, etc.
-  // TODO(armansito): Define constants for the above keys in
-  // service_constants.h (Also see TODO in cellular_service.cc:35).
-  const Stringmap &online_payment_url_template() const {
-    return online_payment_url_template_;
-  }
-
-  bool home_provider_requires_roaming() const {
-    return home_provider_requires_roaming_;
-  }
-
- private:
-  // These methods notify observers of events.
-  void NotifyHomeProviderInfoChanged();
-  void NotifyServingOperatorInfoChanged();
-  void NotifyApnListChanged();
-  void NotifyOnlinePaymentUrlTemplateChanged();
-
-  // It is OK to use a raw pointer here, as:
-  //   1. ModemInfo is not owned by MobileOperator.
-  //   2. ModemInfo has a longer life-time than MobileOperator.
-  ModemInfo *modem_info_;
-
-  Stringmap home_provider_;
-  Stringmap serving_operator_;
-  Stringmaps apn_list_;
-  Stringmap online_payment_url_template_;
-  bool home_provider_requires_roaming_;
-
-  ObserverList<Observer> observers_;
-
-  DISALLOW_COPY_AND_ASSIGN(MobileOperator);
-};
-
-}  // namespace shill
-
-#endif  //  SHILL_MOBILE_OPERATOR_H_
diff --git a/mobile_operator_unittest.cc b/mobile_operator_unittest.cc
deleted file mode 100644
index 9ec044b..0000000
--- a/mobile_operator_unittest.cc
+++ /dev/null
@@ -1,651 +0,0 @@
-// Copyright (c) 2013 The Chromium OS 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 "shill/mobile_operator.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include "shill/cellular_service.h"  // TODO(armansito): Remove once OLP moves.
-#include "shill/mock_cellular_operator_info.h"
-#include "shill/mock_modem_info.h"
-
-using testing::_;
-using testing::Mock;
-using testing::Return;
-
-namespace shill {
-
-namespace {
-
-const char kTestMobileProviderDbPath[] = "provider_db_unittest.bfd";
-const char kTestUnknownOperatorCode[] = "unknown-code";
-const char kTestUnknownOperatorName[] = "unknown-name";
-const char kTestOperatorInfoCodeMccmnc[] = "test-mccmnc";
-const char kTestOperatorInfoCodeSid[] = "test-sid";
-const char kTestNoOlpOperatorInfoCode[] = "no-olp-code";
-const char kTestOperatorInfoName[] = "test-operator-name";
-const char kTestOperatorInfoCountry[] = "test-country";
-const char kTestOlpUrl[] = "test-url";
-const char kTestOlpMethod[] = "test-method";
-const char kTestOlpPostData[] = "test-post-data";
-const char kTestLocalizedName[] = "test-localized-name";
-const char kTestLocalizedNameLanguage[] = "test-localized-name-language";
-const char kTestApn0[] = "test-apn0";
-const char kTestApnUsername0[] = "test-apn-username0";
-const char kTestApnPassword0[] = "test-apn-password0";
-const char kTestApn1[] = "test-apn1";
-const char kTestApnUsername1[] = "test-apn-username1";
-const char kTestApnPassword1[] = "test-apn-password1";
-
-const char kProviderDbCode0[] = "22803";
-const char kProviderDbName0[] = "Orange";
-const char kProviderDbCountry0[] = "ch";
-const char kProviderDbCode1[] = "310038";
-const char kProviderDbName1[] = "AT&T";
-const char kProviderDbCountry1[] = "us";
-
-}  // namespace
-
-class TestMobileOperatorObserver : public MobileOperator::Observer {
- public:
-  MOCK_METHOD1(OnHomeProviderInfoChanged, void(const MobileOperator *));
-  MOCK_METHOD1(OnServingOperatorInfoChanged, void(const MobileOperator *));
-  MOCK_METHOD1(OnApnListChanged, void(const MobileOperator *));
-  MOCK_METHOD1(OnOnlinePaymentUrlTemplateChanged,
-               void(const MobileOperator *));
-};
-
-class MobileOperatorTest : public testing::Test {
- public:
-  MobileOperatorTest()
-    : modem_info_(NULL, NULL, NULL, NULL, NULL),
-      operator_(&modem_info_) {}
-
-  void SetUp() {
-    operator_.AddObserver(&observer_);
-    modem_info_.SetProviderDB(kTestMobileProviderDbPath);
-    SetupCellularOperatorInfo();
-  }
-
-  void TearDown() {
-    operator_.RemoveObserver(&observer_);
-  }
-
-  // Called from SetUp.
-  void SetupCellularOperatorInfo() {
-    test_olp_.SetURL(kTestOlpUrl);
-    test_olp_.SetMethod(kTestOlpMethod);
-    test_olp_.SetPostData(kTestOlpPostData);
-    CellularOperatorInfo::LocalizedName name;
-    name.name = kTestOperatorInfoName;
-    test_operator_.name_list_.push_back(name);
-    test_operator_.country_ = kTestOperatorInfoCountry;
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetCellularOperatorByMCCMNC(_))
-      .WillByDefault(Return(nullptr));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetCellularOperatorByMCCMNC(kTestOperatorInfoCodeMccmnc))
-      .WillByDefault(Return(&test_operator_));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetCellularOperatorByMCCMNC(kTestNoOlpOperatorInfoCode))
-      .WillByDefault(Return(&test_operator_));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetCellularOperatorBySID(_))
-      .WillByDefault(Return(nullptr));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetCellularOperatorBySID(kTestOperatorInfoCodeSid))
-      .WillByDefault(Return(&test_operator_));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetCellularOperatorBySID(kTestNoOlpOperatorInfoCode))
-      .WillByDefault(Return(&test_operator_));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetOLPByMCCMNC(_))
-      .WillByDefault(Return(nullptr));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetOLPByMCCMNC(kTestOperatorInfoCodeMccmnc))
-      .WillByDefault(Return(&test_olp_));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetOLPBySID(_))
-      .WillByDefault(Return(nullptr));
-    ON_CALL(*modem_info_.mock_cellular_operator_info(),
-            GetOLPBySID(kTestOperatorInfoCodeSid))
-      .WillByDefault(Return(&test_olp_));
-  }
-
-  // Called from tests.
-  void SetupApnList() {
-    CellularOperatorInfo::LocalizedName localized_name(
-        kTestLocalizedName, kTestLocalizedNameLanguage);
-    CellularOperatorInfo::MobileAPN *apn = new CellularOperatorInfo::MobileAPN;
-    apn->apn = kTestApn0;
-    apn->username = kTestApnUsername0;
-    apn->password = kTestApnPassword0;
-    apn->name_list.push_back(localized_name);
-    test_operator_.apn_list_.push_back(apn);  // Passes ownership.
-
-    apn = new CellularOperatorInfo::MobileAPN;
-    apn->apn = kTestApn1;
-    apn->username = kTestApnUsername1;
-    apn->password = kTestApnPassword1;
-    apn->name_list.push_back(CellularOperatorInfo::LocalizedName(
-        kTestOperatorInfoName, ""));
-    apn->name_list.push_back(localized_name);
-    test_operator_.apn_list_.push_back(apn);  // Passes ownership.
-  }
-
- protected:
-  MockModemInfo modem_info_;
-  MobileOperator operator_;
-  TestMobileOperatorObserver observer_;
-  CellularOperatorInfo::CellularOperator test_operator_;
-  CellularService::OLP test_olp_;
-};
-
-TEST_F(MobileOperatorTest, OtaOperatorInfoReceivedNotFound) {
-  EXPECT_TRUE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.apn_list().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-
-  operator_.OtaOperatorInfoReceived(
-      "", "", MobileOperator::kOperatorCodeTypeMCCMNC);
-  operator_.OtaOperatorInfoReceived(
-      "", "", MobileOperator::kOperatorCodeTypeSID);
-  Mock::VerifyAndClearExpectations(&observer_);
-
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(2);
-  operator_.OtaOperatorInfoReceived(kTestUnknownOperatorCode, "",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_EQ(kTestUnknownOperatorCode,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(operator_.serving_operator().end(),
-            operator_.serving_operator().find("name"));
-  operator_.OtaOperatorInfoReceived("", kTestUnknownOperatorName,
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  EXPECT_EQ(operator_.serving_operator().end(),
-            operator_.serving_operator().find("code"));
-  EXPECT_EQ(kTestUnknownOperatorName,
-            operator_.serving_operator().find("name")->second);
-
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.apn_list().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-}
-
-TEST_F(MobileOperatorTest, SimOperatorInfoReceivedNotFound) {
-  EXPECT_TRUE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.apn_list().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-
-  operator_.SimOperatorInfoReceived("", "");
-  Mock::VerifyAndClearExpectations(&observer_);
-
-  operator_.SimOperatorInfoReceived(kTestUnknownOperatorCode, "");
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_EQ(kTestUnknownOperatorCode,
-            operator_.home_provider().find("code")->second);
-  EXPECT_EQ(operator_.home_provider().end(),
-            operator_.home_provider().find("name"));
-
-  operator_.SimOperatorInfoReceived("", kTestUnknownOperatorName);
-  EXPECT_EQ(operator_.home_provider().end(),
-            operator_.home_provider().find("code"));
-  EXPECT_EQ(kTestUnknownOperatorName,
-            operator_.home_provider().find("name")->second);
-
-  EXPECT_TRUE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.apn_list().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-}
-
-TEST_F(MobileOperatorTest, OtaOperatorInfoReceivedMccmnc) {
-  // Operator code only.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kTestNoOlpOperatorInfoCode, "",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestNoOlpOperatorInfoCode,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(kTestOperatorInfoCountry,
-            operator_.serving_operator().find("country")->second);
-
-  // Update to same value.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  operator_.OtaOperatorInfoReceived(kTestNoOlpOperatorInfoCode,
-                                    kTestOperatorInfoName,
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestNoOlpOperatorInfoCode,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(kTestOperatorInfoCountry,
-            operator_.serving_operator().find("country")->second);
-
-  // Update With OLP.
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kTestOperatorInfoCodeMccmnc, "",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeMccmnc,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_FALSE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestOlpUrl,
-            operator_.online_payment_url_template().find("url")->second);
-  EXPECT_EQ(kTestOlpMethod,
-            operator_.online_payment_url_template().find("method")->second);
-  EXPECT_EQ(kTestOlpPostData,
-            operator_.online_payment_url_template().find("postdata")->second);
-
-  // Update just the operator name.
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  operator_.OtaOperatorInfoReceived(kTestOperatorInfoCodeMccmnc, "banana",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeMccmnc,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ("banana",
-            operator_.serving_operator().find("name")->second);
-  EXPECT_FALSE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestOlpUrl,
-            operator_.online_payment_url_template().find("url")->second);
-  EXPECT_EQ(kTestOlpMethod,
-            operator_.online_payment_url_template().find("method")->second);
-  EXPECT_EQ(kTestOlpPostData,
-            operator_.online_payment_url_template().find("postdata")->second);
-}
-
-TEST_F(MobileOperatorTest, OtaOperatorInfoReceivedSid) {
-  // Operator code only.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kTestNoOlpOperatorInfoCode, "",
-                                    MobileOperator::kOperatorCodeTypeSID);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestNoOlpOperatorInfoCode,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(kTestOperatorInfoCountry,
-            operator_.serving_operator().find("country")->second);
-
-  // Update to same value.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  operator_.OtaOperatorInfoReceived(kTestNoOlpOperatorInfoCode,
-                                    kTestOperatorInfoName,
-                                    MobileOperator::kOperatorCodeTypeSID);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestNoOlpOperatorInfoCode,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(kTestOperatorInfoCountry,
-            operator_.serving_operator().find("country")->second);
-
-  // Update With OLP.
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kTestOperatorInfoCodeSid, "",
-                                    MobileOperator::kOperatorCodeTypeSID);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeSid,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_FALSE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestOlpUrl,
-            operator_.online_payment_url_template().find("url")->second);
-  EXPECT_EQ(kTestOlpMethod,
-            operator_.online_payment_url_template().find("method")->second);
-  EXPECT_EQ(kTestOlpPostData,
-            operator_.online_payment_url_template().find("postdata")->second);
-
-  // Update just the operator name.
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  operator_.OtaOperatorInfoReceived(kTestOperatorInfoCodeSid, "banana",
-                                    MobileOperator::kOperatorCodeTypeSID);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeSid,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ("banana",
-            operator_.serving_operator().find("name")->second);
-  EXPECT_FALSE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestOlpUrl,
-            operator_.online_payment_url_template().find("url")->second);
-  EXPECT_EQ(kTestOlpMethod,
-            operator_.online_payment_url_template().find("method")->second);
-  EXPECT_EQ(kTestOlpPostData,
-            operator_.online_payment_url_template().find("postdata")->second);
-}
-
-TEST_F(MobileOperatorTest, OtaReceivedMobileProviderDb) {
-  // Update with operator ID that doesn't exist in COI but is in
-  // the mobile provider db.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kProviderDbCode0, "",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kProviderDbCode0,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kProviderDbName0,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(kProviderDbCountry0,
-            operator_.serving_operator().find("country")->second);
-
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kProviderDbCode1, "",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kProviderDbCode1,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(kProviderDbName1,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(kProviderDbCountry1,
-            operator_.serving_operator().find("country")->second);
-
-  // Look up by name.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived("", kProviderDbName0,
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(operator_.serving_operator().end(),
-            operator_.serving_operator().find("code"));
-  EXPECT_EQ(kProviderDbName0,
-            operator_.serving_operator().find("name")->second);
-  EXPECT_EQ(operator_.serving_operator().end(),
-            operator_.serving_operator().find("country"));
-
-  // mobile provider DB doesn't support SID.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(1);
-  operator_.OtaOperatorInfoReceived(kProviderDbCode0, "",
-                                    MobileOperator::kOperatorCodeTypeSID);
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kProviderDbCode0,
-            operator_.serving_operator().find("code")->second);
-  EXPECT_EQ(operator_.serving_operator().end(),
-            operator_.serving_operator().find("name"));
-  EXPECT_EQ(operator_.serving_operator().end(),
-            operator_.serving_operator().find("country"));
-}
-
-TEST_F(MobileOperatorTest, SimOperatorInfoReceived) {
-  // Operator code only.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  operator_.SimOperatorInfoReceived(kTestNoOlpOperatorInfoCode, "");
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestNoOlpOperatorInfoCode,
-            operator_.home_provider().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.home_provider().find("name")->second);
-  EXPECT_EQ(kTestOperatorInfoCountry,
-            operator_.home_provider().find("country")->second);
-
-  // Update to same value.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  operator_.SimOperatorInfoReceived(kTestNoOlpOperatorInfoCode, "");
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestNoOlpOperatorInfoCode,
-            operator_.home_provider().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.home_provider().find("name")->second);
-  EXPECT_EQ(kTestOperatorInfoCountry,
-            operator_.home_provider().find("country")->second);
-
-  // Update with OLP: OLP shouldn't change.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  operator_.SimOperatorInfoReceived(kTestOperatorInfoCodeMccmnc, "");
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeMccmnc,
-            operator_.home_provider().find("code")->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.home_provider().find("name")->second);
-
-  // Update just the operator name.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  operator_.SimOperatorInfoReceived(kTestOperatorInfoCodeMccmnc, "banana");
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeMccmnc,
-            operator_.home_provider().find("code")->second);
-  EXPECT_EQ("banana",
-            operator_.home_provider().find("name")->second);
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-
-  // Try passing a SID. No matching entry will be found.
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(1);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  operator_.SimOperatorInfoReceived(kTestOperatorInfoCodeSid, "");
-  Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_EQ(kTestOperatorInfoCodeSid,
-            operator_.home_provider().find("code")->second);
-  EXPECT_EQ(operator_.home_provider().end(),
-            operator_.home_provider().find("name"));
-  EXPECT_EQ(operator_.home_provider().end(),
-            operator_.home_provider().find("country"));
-}
-
-TEST_F(MobileOperatorTest, ApnListUpdate) {
-  SetupApnList();
-  EXPECT_TRUE(operator_.apn_list().empty());
-  EXPECT_TRUE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-
-  // Set MCCMNC OTA.
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(3);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(3);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(2);
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(0);
-  operator_.OtaOperatorInfoReceived(kTestOperatorInfoCodeMccmnc, "",
-                                    MobileOperator::kOperatorCodeTypeMCCMNC);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_FALSE(operator_.online_payment_url_template().empty());
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_EQ(2, operator_.apn_list().size());
-  EXPECT_EQ(kTestApn0, operator_.apn_list()[0].find(kApnProperty)->second);
-  EXPECT_EQ(kTestApnUsername0,
-            operator_.apn_list()[0].find(kApnUsernameProperty)->second);
-  EXPECT_EQ(kTestApnPassword0,
-            operator_.apn_list()[0].find(kApnPasswordProperty)->second);
-  EXPECT_EQ(kTestLocalizedName,
-            operator_.apn_list()[0].find(kApnLocalizedNameProperty)->second);
-  EXPECT_EQ(kTestLocalizedNameLanguage,
-            operator_.apn_list()[0].find(kApnLanguageProperty)->second);
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnNameProperty));
-
-  EXPECT_EQ(kTestApn1, operator_.apn_list()[1].find("apn")->second);
-  EXPECT_EQ(kTestApnUsername1,
-            operator_.apn_list()[1].find(kApnUsernameProperty)->second);
-  EXPECT_EQ(kTestApnPassword1,
-            operator_.apn_list()[1].find(kApnPasswordProperty)->second);
-  EXPECT_EQ(kTestLocalizedName,
-            operator_.apn_list()[1].find(kApnLocalizedNameProperty)->second);
-  EXPECT_EQ(kTestLocalizedNameLanguage,
-            operator_.apn_list()[1].find(kApnLanguageProperty)->second);
-  EXPECT_EQ(kTestOperatorInfoName,
-            operator_.apn_list()[1].find(kApnNameProperty)->second);
-
-  // Update APN list via provider DB.
-  operator_.OtaOperatorInfoReceived(
-      "22801", "", MobileOperator::kOperatorCodeTypeMCCMNC);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_TRUE(operator_.home_provider().empty());
-  EXPECT_EQ(1, operator_.apn_list().size());
-  EXPECT_EQ("gprs.swisscom.ch",
-            operator_.apn_list()[0].find(kApnProperty)->second);
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnUsernameProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnPasswordProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnLocalizedNameProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnLanguageProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnNameProperty));
-
-  operator_.OtaOperatorInfoReceived(
-      "310160", "", MobileOperator::kOperatorCodeTypeMCCMNC);
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_TRUE(operator_.home_provider().empty());
-
-  EXPECT_EQ(4, operator_.apn_list().size());
-  EXPECT_EQ("epc.tmobile.com",
-            operator_.apn_list()[0].find(kApnProperty)->second);
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnUsernameProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnPasswordProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnLocalizedNameProperty));
-  EXPECT_EQ(operator_.apn_list()[0].end(),
-            operator_.apn_list()[0].find(kApnLanguageProperty));
-  EXPECT_EQ("Internet/WebConnect",
-            operator_.apn_list()[0].find(kApnNameProperty)->second);
-
-  EXPECT_EQ("wap.voicestream.com",
-            operator_.apn_list()[1].find(kApnProperty)->second);
-  EXPECT_EQ(operator_.apn_list()[1].end(),
-            operator_.apn_list()[1].find(kApnUsernameProperty));
-  EXPECT_EQ(operator_.apn_list()[1].end(),
-            operator_.apn_list()[1].find(kApnPasswordProperty));
-  EXPECT_EQ(operator_.apn_list()[1].end(),
-            operator_.apn_list()[1].find(kApnLocalizedNameProperty));
-  EXPECT_EQ(operator_.apn_list()[1].end(),
-            operator_.apn_list()[1].find(kApnLanguageProperty));
-  EXPECT_EQ("Web2Go/t-zones",
-            operator_.apn_list()[1].find(kApnNameProperty)->second);
-
-  EXPECT_EQ("internet2.voicestream.com",
-            operator_.apn_list()[2].find(kApnProperty)->second);
-  EXPECT_EQ(operator_.apn_list()[2].end(),
-            operator_.apn_list()[2].find(kApnUsernameProperty));
-  EXPECT_EQ(operator_.apn_list()[2].end(),
-            operator_.apn_list()[2].find(kApnPasswordProperty));
-  EXPECT_EQ(operator_.apn_list()[2].end(),
-            operator_.apn_list()[2].find(kApnLocalizedNameProperty));
-  EXPECT_EQ(operator_.apn_list()[2].end(),
-            operator_.apn_list()[2].find(kApnLanguageProperty));
-  EXPECT_EQ("Internet (old)",
-            operator_.apn_list()[2].find(kApnNameProperty)->second);
-
-  EXPECT_EQ("internet3.voicestream.com",
-            operator_.apn_list()[3].find(kApnProperty)->second);
-  EXPECT_EQ(operator_.apn_list()[3].end(),
-            operator_.apn_list()[3].find(kApnUsernameProperty));
-  EXPECT_EQ(operator_.apn_list()[3].end(),
-            operator_.apn_list()[3].find(kApnPasswordProperty));
-  EXPECT_EQ(operator_.apn_list()[3].end(),
-            operator_.apn_list()[3].find(kApnLocalizedNameProperty));
-  EXPECT_EQ(operator_.apn_list()[3].end(),
-            operator_.apn_list()[3].find(kApnLanguageProperty));
-  EXPECT_EQ("Internet with VPN (old)",
-            operator_.apn_list()[3].find(kApnNameProperty)->second);
-  Mock::VerifyAndClearExpectations(&observer_);
-
-  // Set from SIM. This shouldn't update the APN list.
-  EXPECT_CALL(observer_, OnApnListChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnServingOperatorInfoChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnOnlinePaymentUrlTemplateChanged(_)).Times(0);
-  EXPECT_CALL(observer_, OnHomeProviderInfoChanged(_)).Times(1);
-  operator_.SimOperatorInfoReceived(kTestOperatorInfoCodeMccmnc, "");
-  EXPECT_FALSE(operator_.serving_operator().empty());
-  EXPECT_TRUE(operator_.online_payment_url_template().empty());
-  EXPECT_FALSE(operator_.home_provider().empty());
-  EXPECT_EQ(4, operator_.apn_list().size());
-}
-
-}  // namespace shill
