Geolocation cleanup: run clang-format

device/geolocation/location_api_adapter_android.cc

 // Copyright (c) 2012 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 "device/geolocation/location_api_adapter_android.h"
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
@@ skipping 13 matching lines @@
                                  jdouble longitude,
                                  jdouble time_stamp,
                                  jboolean has_altitude,
                                  jdouble altitude,
                                  jboolean has_accuracy,
                                  jdouble accuracy,
                                  jboolean has_heading,
                                  jdouble heading,
                                  jboolean has_speed,
                                  jdouble speed) {
-  AndroidLocationApiAdapter::OnNewLocationAvailable(latitude, longitude,
-      time_stamp, has_altitude, altitude, has_accuracy, accuracy,
-      has_heading, heading, has_speed, speed);
+  AndroidLocationApiAdapter::OnNewLocationAvailable(
+      latitude, longitude, time_stamp, has_altitude, altitude, has_accuracy,
+      accuracy, has_heading, heading, has_speed, speed);
 }
 
 static void NewErrorAvailable(JNIEnv* env,
                               const JavaParamRef<jclass>&,
                               const JavaParamRef<jstring>& message) {
   AndroidLocationApiAdapter::OnNewErrorAvailable(env, message);
 }
 
 namespace device {
 
 AndroidLocationApiAdapter::AndroidLocationApiAdapter()
-    : location_provider_(NULL) {
-}
+    : location_provider_(NULL) {}
 
 AndroidLocationApiAdapter::~AndroidLocationApiAdapter() {
   CHECK(!location_provider_);
   CHECK(!task_runner_.get());
   CHECK(java_location_provider_android_object_.is_null());
 }
 
 bool AndroidLocationApiAdapter::Start(
-    LocationProviderAndroid* location_provider, bool high_accuracy) {
+    LocationProviderAndroid* location_provider,
+    bool high_accuracy) {
   JNIEnv* env = AttachCurrentThread();
   if (!location_provider_) {
     location_provider_ = location_provider;
     CHECK(java_location_provider_android_object_.is_null());
     CreateJavaObject(env);
     {
       base::AutoLock lock(lock_);
       CHECK(!task_runner_.get());
       task_runner_ = base::ThreadTaskRunnerHandle::Get();
     }
   }
   // At this point we should have all our pre-conditions ready, and they'd only
   // change in Stop() which must be called on the same thread as here.
   CHECK(location_provider_);
   CHECK(task_runner_.get());
   CHECK(!java_location_provider_android_object_.is_null());
   // We'll start receiving notifications from java in the main thread looper
   // until Stop() is called.
-  return Java_LocationProviderAdapter_start(env,
-      java_location_provider_android_object_.obj(), high_accuracy);
+  return Java_LocationProviderAdapter_start(
+      env, java_location_provider_android_object_.obj(), high_accuracy);
 }
 
 void AndroidLocationApiAdapter::Stop() {
   if (!location_provider_) {
     CHECK(!task_runner_.get());
     CHECK(java_location_provider_android_object_.is_null());
     return;
   }
 
   {
@@ skipping 13 matching lines @@
 void AndroidLocationApiAdapter::NotifyProviderNewGeoposition(
     const Geoposition& geoposition) {
   // Called on the geolocation thread, safe to access location_provider_ here.
   if (GetInstance()->location_provider_) {
     CHECK(GetInstance()->task_runner_->BelongsToCurrentThread());
     GetInstance()->location_provider_->NotifyNewGeoposition(geoposition);
   }
 }
 
 // static
-void AndroidLocationApiAdapter::OnNewLocationAvailable(
-    double latitude, double longitude, double time_stamp,
-    bool has_altitude, double altitude,
-    bool has_accuracy, double accuracy,
-    bool has_heading, double heading,
-    bool has_speed, double speed) {
+void AndroidLocationApiAdapter::OnNewLocationAvailable(double latitude,
+                                                       double longitude,
+                                                       double time_stamp,
+                                                       bool has_altitude,
+                                                       double altitude,
+                                                       bool has_accuracy,
+                                                       double accuracy,
+                                                       bool has_heading,
+                                                       double heading,
+                                                       bool has_speed,
+                                                       double speed) {
   Geoposition position;
   position.latitude = latitude;
   position.longitude = longitude;
   position.timestamp = base::Time::FromDoubleT(time_stamp);
   if (has_altitude)
     position.altitude = altitude;
   if (has_accuracy)
     position.accuracy = accuracy;
   if (has_heading)
     position.heading = heading;
@@ skipping 18 matching lines @@
 }
 
 // static
 bool AndroidLocationApiAdapter::RegisterGeolocationService(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void AndroidLocationApiAdapter::CreateJavaObject(JNIEnv* env) {
   // Create the Java LocationProviderAdapter object.
   java_location_provider_android_object_.Reset(
-      Java_LocationProviderAdapter_create(env,
-          base::android::GetApplicationContext()));
+      Java_LocationProviderAdapter_create(
+          env, base::android::GetApplicationContext()));
   CHECK(!java_location_provider_android_object_.is_null());
 }
 
 void AndroidLocationApiAdapter::OnNewGeopositionInternal(
     const Geoposition& geoposition) {
   base::AutoLock lock(lock_);
   if (!task_runner_.get())
     return;
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AndroidLocationApiAdapter::NotifyProviderNewGeoposition,
                  geoposition));
 }
 
 }  // namespace device