Cleanup: Remove unneeded browser_thread.h usage.

chrome/browser/device_orientation/provider_impl.cc

 // Copyright (c) 2010 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 <cmath>
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "base/task.h"
-#include "chrome/browser/browser_thread.h"
+#include "base/thread.h"
 #include "chrome/browser/device_orientation/orientation.h"
 #include "chrome/browser/device_orientation/provider_impl.h"
 
 namespace device_orientation {
 
 ProviderImpl::ProviderImpl(const DataFetcherFactory factories[])
     : creator_loop_(MessageLoop::current()),
       ALLOW_THIS_IN_INITIALIZER_LIST(do_poll_method_factory_(this)) {
   for (const DataFetcherFactory* fp = factories; *fp; ++fp)
     factories_.push_back(*fp);
@@ skipping 121 matching lines @@
 
 void ProviderImpl::ScheduleDoPoll() {
   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 
   Task* task = do_poll_method_factory_.NewRunnableMethod(&ProviderImpl::DoPoll);
   MessageLoop* polling_loop = polling_thread_->message_loop();
   polling_loop->PostDelayedTask(FROM_HERE, task, SamplingIntervalMs());
 }
 
 namespace {
+
 bool IsElementSignificantlyDifferent(bool can_provide_element1,
                                      bool can_provide_element2,
                                      double element1,
                                      double element2) {
   const double kThreshold = 0.1;
 
   if (can_provide_element1 != can_provide_element2)
     return true;
   if (can_provide_element1 &&
       std::fabs(element1 - element2) >= kThreshold)
     return true;
   return false;
 }
-} // namespace
+}  // namespace
 
 // Returns true if two orientations are considered different enough that
 // observers should be notified of the new orientation.
 bool ProviderImpl::SignificantlyDifferent(const Orientation& o1,
                                           const Orientation& o2) {
   return IsElementSignificantlyDifferent(o1.can_provide_alpha_,
                                          o2.can_provide_alpha_,
                                          o1.alpha_,
                                          o2.alpha_) ||
       IsElementSignificantlyDifferent(o1.can_provide_beta_,
@@ skipping 12 matching lines @@
 
   int fetcher_interval = data_fetcher_->MinSamplingIntervalMs();
 
   if (fetcher_interval > kDesiredSamplingIntervalMs)
     return fetcher_interval;
   else
     return kDesiredSamplingIntervalMs;
 }
 
 }  // namespace device_orientation