Hooks together Geolocation Feature in the Client and Engine.

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 "base/message_loop/message_loop.h"
+#include "base/run_loop.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 "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"
@@ skipping 12 matching lines @@
   GeolocationCoordinatesMessage* coordinates_message =
       geolocation_message->mutable_coordinates();
   coordinates_message->set_latitude(-42.0);
   coordinates_message->set_longitude(17.3);
   coordinates_message->set_altitude(123.4);
   coordinates_message->set_accuracy(73.7);
 
   net::TestCompletionCallback cb;
   processor->ProcessMessage(std::move(message), cb.callback());
   EXPECT_EQ(net::OK, cb.WaitForResult());
+  base::RunLoop().RunUntilIdle();
 }
 
 void SendMockErrorMessage(BlimpMessageProcessor* processor,
                           GeolocationErrorMessage::ErrorCode error,
                           std::string error_message) {
   GeolocationMessage* geolocation_message;
   std::unique_ptr<BlimpMessage> message =
       CreateBlimpMessage(&geolocation_message);
   GeolocationErrorMessage* geolocation_error_message =
       geolocation_message->mutable_error();
   geolocation_error_message->set_error_code(error);
   geolocation_error_message->set_error_message(error_message);
 
   net::TestCompletionCallback cb;
   processor->ProcessMessage(std::move(message), cb.callback());
   EXPECT_EQ(net::OK, cb.WaitForResult());
+  base::RunLoop().RunUntilIdle();
 }
 
 void SendMalformedMessage(BlimpMessageProcessor* processor) {
   GeolocationMessage* geolocation_message;
   std::unique_ptr<BlimpMessage> message =
       CreateBlimpMessage(&geolocation_message);
 
   net::TestCompletionCallback cb;
   processor->ProcessMessage(std::move(message), cb.callback());
   EXPECT_EQ(net::OK, cb.WaitForResult());
@@ skipping 40 matching lines @@
 
   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_;
 
+  // Runs tasks posted during the processing of incoming messages.
+  base::MessageLoop message_loop_;
+
   EngineGeolocationFeature feature_;
   std::unique_ptr<device::LocationProvider> location_provider_;
   device::LocationProvider::LocationProviderUpdateCallback mock_callback_;
   device::Geoposition received_position;
 };
 
 TEST_F(EngineGeolocationFeatureTest, LocationReceived) {
   SendMockLocationMessage(&feature_);
   EXPECT_EQ(device::Geoposition::ERROR_CODE_NONE,
             received_position.error_code);
@@ skipping 68 matching lines @@
                       GeolocationSetInterestLevelMessage::NO_INTEREST),
                   _))
       .Times(1);
 
   location_provider_->StartProvider(true);
   location_provider_->OnPermissionGranted();
 }
 
 }  // namespace engine
 }  // namespace blimp