Checks to see if the position is valid before OnLocationUpdate call.

blimp/client/core/geolocation/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/client/core/geolocation/geolocation_feature.h"
 
 #include <memory>
 #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/net/test_common.h"
 #include "device/geolocation/geoposition.h"
 #include "device/geolocation/location_provider.h"
 #include "device/geolocation/mock_location_provider.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::InSequence;
 using testing::Invoke;
+using testing::ReturnRef;
 using testing::SaveArg;
 using testing::StrictMock;
 using testing::_;
 
 namespace blimp {
 namespace client {
 
 const double kLatitude = -42.0;
 const double kLongitude = 17.3;
 const double kAltitude = 123.4;
@@ skipping 138 matching lines @@
   EXPECT_CALL(
       *out_processor_,
       MockableProcessMessage(
           EqualsError(GeolocationErrorMessage::POSITION_UNAVAILABLE), _));
   EXPECT_CALL(*out_processor_,
               MockableProcessMessage(
                   EqualsError(GeolocationErrorMessage::PERMISSION_DENIED), _));
   EXPECT_CALL(
       *out_processor_,
       MockableProcessMessage(EqualsError(GeolocationErrorMessage::TIMEOUT), _));
+  EXPECT_CALL(*location_provider_, GetPosition()).Times(3)
+      .WillRepeatedly(ReturnRef(position_));
 
   device::Geoposition err_position;
   err_position.error_code =
       device::Geoposition::ErrorCode::ERROR_CODE_POSITION_UNAVAILABLE;
   callback_.Run(location_provider_, err_position);
 
   err_position.error_code =
       device::Geoposition::ErrorCode::ERROR_CODE_PERMISSION_DENIED;
   callback_.Run(location_provider_, err_position);
 
   err_position.error_code = device::Geoposition::ErrorCode::ERROR_CODE_TIMEOUT;
   callback_.Run(location_provider_, err_position);
 }
 
 TEST_F(GeolocationFeatureTest, NoRepeatSendsWithMessagePending) {
   EXPECT_CALL(*out_processor_,
               MockableProcessMessage(EqualsDefaultGeoposition(), _));
   callback_.Run(location_provider_, position_);
   callback_.Run(location_provider_, position_);
   callback_.Run(location_provider_, position_);
 }
 
 TEST_F(GeolocationFeatureTest, MessageSendsAfterAcknowledgement) {
   EXPECT_CALL(*out_processor_,
               MockableProcessMessage(EqualsDefaultGeoposition(), _))
       .WillOnce(Invoke(
           this, &GeolocationFeatureTest_MessageSendsAfterAcknowledgement_Test::
                     ReportProcessMessageSuccess));
+
   device::Geoposition position;
   position.latitude = 1.0;
   position.longitude = 1.0;
   position.altitude = 1.0;
   position.accuracy = 1.0;
+  position.timestamp = base::Time::Now();
+  EXPECT_CALL(*location_provider_, GetPosition()).WillOnce(ReturnRef(position));
+
   EXPECT_CALL(*out_processor_,
               MockableProcessMessage(EqualGeoposition(1.0, 1.0, 1.0, 1.0), _));
   callback_.Run(location_provider_, position_);
   callback_.Run(location_provider_, position);
 }
 
 TEST_F(GeolocationFeatureTest, ProcessMessageHandlesNullCallback) {
   EXPECT_CALL(*location_provider_, OnPermissionGranted());
 
   GeolocationMessage* geolocation_message;
   std::unique_ptr<BlimpMessage> message =
       CreateBlimpMessage(&geolocation_message);
   geolocation_message->mutable_request_refresh();
 
   feature_->ProcessMessage(std::move(message), net::CompletionCallback());
 }
 
 }  // namespace client
 }  // namespace blimp