Revert of Reland: Geolocation: move from content/browser to device/ (patchset #2 id:20001 of https:…

blimp/engine/feature/geolocation/engine_geolocation_feature.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 <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/geolocation.pb.h"
-#include "device/geolocation/geolocation_delegate.h"
-#include "device/geolocation/location_provider.h"
-#include "device/geolocation/geoposition.h"
+#include "content/public/browser/geolocation_delegate.h"
+#include "content/public/browser/location_provider.h"
+#include "content/public/common/geoposition.h"
 #include "net/base/net_errors.h"
 
 namespace blimp {
 namespace engine {
 namespace {
-class BlimpGeolocationDelegate : public device::GeolocationDelegate {
+class BlimpGeolocationDelegate : public content::GeolocationDelegate {
  public:
   explicit BlimpGeolocationDelegate(
       base::WeakPtr<BlimpLocationProvider::Delegate> feature_delegate) {
     feature_delegate_ = feature_delegate;
   }
 
   bool UseNetworkLocationProviders() final { return false; }
 
-  std::unique_ptr<device::LocationProvider> OverrideSystemLocationProvider()
+  std::unique_ptr<content::LocationProvider> OverrideSystemLocationProvider()
       final {
     return base::WrapUnique(new BlimpLocationProvider(feature_delegate_));
   }
 
  private:
   base::WeakPtr<BlimpLocationProvider::Delegate> feature_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpGeolocationDelegate);
 };
 
-device::Geoposition::ErrorCode ConvertErrorCode(
+content::Geoposition::ErrorCode ConvertErrorCode(
     const GeolocationErrorMessage::ErrorCode& error_code) {
   switch (error_code) {
     case GeolocationErrorMessage::PERMISSION_DENIED:
-      return device::Geoposition::ErrorCode::ERROR_CODE_PERMISSION_DENIED;
+      return content::Geoposition::ErrorCode::ERROR_CODE_PERMISSION_DENIED;
     case GeolocationErrorMessage::POSITION_UNAVAILABLE:
-      return device::Geoposition::ErrorCode::ERROR_CODE_POSITION_UNAVAILABLE;
+      return content::Geoposition::ErrorCode::ERROR_CODE_POSITION_UNAVAILABLE;
     case GeolocationErrorMessage::TIMEOUT:
-      return device::Geoposition::ErrorCode::ERROR_CODE_TIMEOUT;
+      return content::Geoposition::ErrorCode::ERROR_CODE_TIMEOUT;
   }
 }
 
-device::Geoposition ConvertLocationMessage(
+content::Geoposition ConvertLocationMessage(
     const GeolocationCoordinatesMessage& coordinates) {
-  device::Geoposition output;
+  content::Geoposition output;
   output.latitude = coordinates.latitude();
   output.longitude = coordinates.longitude();
   output.altitude = coordinates.altitude();
   output.accuracy = coordinates.accuracy();
   output.altitude_accuracy = coordinates.altitude_accuracy();
   output.heading = coordinates.heading();
   output.speed = coordinates.speed();
   output.timestamp = base::Time::Now();
-  output.error_code = device::Geoposition::ErrorCode::ERROR_CODE_NONE;
+  output.error_code = content::Geoposition::ErrorCode::ERROR_CODE_NONE;
   return output;
 }
 
 }  // namespace
 
 EngineGeolocationFeature::EngineGeolocationFeature() : weak_factory_(this) {}
 
 EngineGeolocationFeature::~EngineGeolocationFeature() {}
 
 void EngineGeolocationFeature::set_outgoing_message_processor(
     std::unique_ptr<BlimpMessageProcessor> message_processor) {
   DCHECK(message_processor);
   outgoing_message_processor_ = std::move(message_processor);
 }
 
-device::GeolocationDelegate*
+content::GeolocationDelegate*
 EngineGeolocationFeature::CreateGeolocationDelegate() {
   return new BlimpGeolocationDelegate(weak_factory_.GetWeakPtr());
 }
 
 void EngineGeolocationFeature::ProcessMessage(
     std::unique_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
   DCHECK_EQ(BlimpMessage::kGeolocation, message->feature_case());
 
   int result = net::OK;
   const GeolocationMessage& geolocation_message = message->geolocation();
   switch (geolocation_message.type_case()) {
     case GeolocationMessage::kCoordinates: {
       const GeolocationCoordinatesMessage& location =
           geolocation_message.coordinates();
-      device::Geoposition output = ConvertLocationMessage(location);
+      content::Geoposition output = ConvertLocationMessage(location);
       NotifyCallback(output);
       break;
     }
     case GeolocationMessage::kError: {
       const GeolocationErrorMessage& error_message =
           geolocation_message.error();
-      device::Geoposition output;
+      content::Geoposition output;
       output.error_message = error_message.error_message();
       output.error_code = ConvertErrorCode(error_message.error_code());
       NotifyCallback(output);
       break;
     }
     case GeolocationMessage::kSetInterestLevel:
     case GeolocationMessage::kRequestRefresh:
     case GeolocationMessage::TYPE_NOT_SET:
       result = net::ERR_UNEXPECTED;
   }
   if (!callback.is_null()) {
     callback.Run(result);
   }
 }
 
 void EngineGeolocationFeature::NotifyCallback(
-    const device::Geoposition& position) {
+    const content::Geoposition& position) {
   geoposition_received_callback_.Run(position);
 }
 
 void EngineGeolocationFeature::RequestAccuracy(
     GeolocationSetInterestLevelMessage::Level level) {
   GeolocationMessage* geolocation_message = nullptr;
   std::unique_ptr<BlimpMessage> blimp_message =
       CreateBlimpMessage(&geolocation_message);
 
   GeolocationSetInterestLevelMessage* geolocation_interest =
@@ skipping 15 matching lines @@
                                               net::CompletionCallback());
 }
 
 void EngineGeolocationFeature::SetUpdateCallback(
     const GeopositionReceivedCallback& callback) {
   geoposition_received_callback_ = callback;
 }
 
 }  // namespace engine
 }  // namespace blimp