Geolocation: move from content/browser to device/

blimp/engine/app/blimp_browser_main_parts.cc

 // Copyright 2015 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/app/blimp_browser_main_parts.h"
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/engine/app/blimp_engine_config.h"
 #include "blimp/engine/app/settings_manager.h"
 #include "blimp/engine/common/blimp_browser_context.h"
 #include "blimp/engine/feature/geolocation/blimp_location_provider.h"
 #include "blimp/engine/session/blimp_engine_session.h"
 #include "blimp/net/blimp_connection.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/geolocation_delegate.h"
-#include "content/public/browser/geolocation_provider.h"
 #include "content/public/common/main_function_params.h"
+#include "device/geolocation/public/cpp/geolocation_delegate.h"
+#include "device/geolocation/public/cpp/geolocation_provider.h"
 #include "net/base/net_module.h"
 #include "net/log/net_log.h"
 
 namespace blimp {
 namespace engine {
 
 namespace {
 // A provider of services needed by Geolocation.
-class BlimpGeolocationDelegate : public content::GeolocationDelegate {
+class BlimpGeolocationDelegate : public device::GeolocationDelegate {
  public:
   BlimpGeolocationDelegate() = default;
 
   bool UseNetworkLocationProviders() final { return false; }
 
-  std::unique_ptr<content::LocationProvider> OverrideSystemLocationProvider()
+  std::unique_ptr<device::LocationProvider> OverrideSystemLocationProvider()
       final {
     return base::WrapUnique(new BlimpLocationProvider());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BlimpGeolocationDelegate);
 };
 
 }  // anonymous namespace
 
@@ skipping 12 matching lines @@
     engine_config_ = BlimpEngineConfig::Create(*cmd_line);
     CHECK(engine_config_);
   }
 }
 
 void BlimpBrowserMainParts::PreMainMessageLoopRun() {
   net_log_.reset(new net::NetLog());
   settings_manager_.reset(new SettingsManager);
   std::unique_ptr<BlimpBrowserContext> browser_context(
       new BlimpBrowserContext(false, net_log_.get()));
-  content::GeolocationProvider::SetGeolocationDelegate(
+  device::GeolocationProvider::SetGeolocationDelegate(
       new BlimpGeolocationDelegate());
   engine_session_.reset(
       new BlimpEngineSession(std::move(browser_context), net_log_.get(),
                              engine_config_.get(), settings_manager_.get()));
   engine_session_->Initialize();
 }
 
 void BlimpBrowserMainParts::PostMainMessageLoopRun() {
   engine_session_.reset();
 }
 
 BlimpBrowserContext* BlimpBrowserMainParts::GetBrowserContext() {
   return engine_session_->browser_context();
 }
 
 SettingsManager* BlimpBrowserMainParts::GetSettingsManager() {
   return settings_manager_.get();
 }
 
 BlobChannelSender* BlimpBrowserMainParts::GetBlobChannelSender() {
   return engine_session_->blob_channel_sender();
 }
 
 BlimpEngineSession* BlimpBrowserMainParts::GetBlimpEngineSession() {
   return engine_session_.get();
 }
 
 }  // namespace engine
 }  // namespace blimp