Reland 2:Geolocation: move from content/browser to device/

blimp/engine/feature/geolocation/engine_geolocation_feature_unittest.cc

 // Copyright 2016 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 "blimp/engine/feature/geolocation/engine_geolocation_feature.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/geolocation.pb.h"
 #include "blimp/net/test_common.h"
-#include "content/public/browser/location_provider.h"
-#include "content/public/common/geoposition.h"
+#include "device/geolocation/geolocation_delegate.h"
+#include "device/geolocation/geoposition.h"
+#include "device/geolocation/location_provider.h"
 #include "net/base/test_completion_callback.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace blimp {
 namespace engine {
 
@@ skipping 72 matching lines @@
         mock_callback_(
             base::Bind(&EngineGeolocationFeatureTest::OnLocationUpdate,
                        base::Unretained(this))) {}
 
   void SetUp() override {
     out_processor_ = new MockBlimpMessageProcessor();
     feature_.set_outgoing_message_processor(base::WrapUnique(out_processor_));
     location_provider_->SetUpdateCallback(mock_callback_);
   }
 
-  void OnLocationUpdate(const content::LocationProvider* provider,
-                        const content::Geoposition& geoposition) {
+  void OnLocationUpdate(const device::LocationProvider* provider,
+                        const device::Geoposition& geoposition) {
     received_position = geoposition;
   }
 
  protected:
   // This is a raw pointer to a class that is owned by the GeolocationFeature.
   MockBlimpMessageProcessor* out_processor_;
 
   EngineGeolocationFeature feature_;
-  std::unique_ptr<content::LocationProvider> location_provider_;
-  content::LocationProvider::LocationProviderUpdateCallback mock_callback_;
-  content::Geoposition received_position;
+  std::unique_ptr<device::LocationProvider> location_provider_;
+  device::LocationProvider::LocationProviderUpdateCallback mock_callback_;
+  device::Geoposition received_position;
 };
 
 TEST_F(EngineGeolocationFeatureTest, LocationReceived) {
   SendMockLocationMessage(&feature_);
-  EXPECT_EQ(content::Geoposition::ERROR_CODE_NONE,
+  EXPECT_EQ(device::Geoposition::ERROR_CODE_NONE,
             received_position.error_code);
   EXPECT_EQ(-42.0, received_position.latitude);
   EXPECT_EQ(17.3, received_position.longitude);
   EXPECT_EQ(123.4, received_position.altitude);
   EXPECT_EQ(73.7, received_position.accuracy);
 }
 
 TEST_F(EngineGeolocationFeatureTest, ErrorRecieved) {
   SendMockErrorMessage(&feature_, GeolocationErrorMessage::PERMISSION_DENIED,
                        "PERMISSION_DENIED");
-  EXPECT_EQ(content::Geoposition::ERROR_CODE_PERMISSION_DENIED,
+  EXPECT_EQ(device::Geoposition::ERROR_CODE_PERMISSION_DENIED,
             received_position.error_code);
   EXPECT_EQ("PERMISSION_DENIED", received_position.error_message);
 
   SendMockErrorMessage(&feature_, GeolocationErrorMessage::POSITION_UNAVAILABLE,
                        "POSITION_UNAVAILABLE");
-  EXPECT_EQ(content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE,
+  EXPECT_EQ(device::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE,
             received_position.error_code);
   EXPECT_EQ("POSITION_UNAVAILABLE", received_position.error_message);
 }
 
 TEST_F(EngineGeolocationFeatureTest, UpdateRequestLevel) {
   EXPECT_CALL(*out_processor_,
               MockableProcessMessage(
                   EqualsUpdatedRequestLevel(
                       GeolocationSetInterestLevelMessage::HIGH_ACCURACY),
                   _))
@@ skipping 41 matching lines @@
                       GeolocationSetInterestLevelMessage::NO_INTEREST),
                   _))
       .Times(1);
 
   location_provider_->StartProvider(true);
   location_provider_->RequestRefresh();
 }
 
 }  // namespace engine
 }  // namespace blimp