Remove //net (except for Android test stuff) and sdch

net/quic/quic_connection_helper.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 "net/quic/quic_connection_helper.h"
-
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/task_runner.h"
-#include "base/time/time.h"
-#include "net/base/io_buffer.h"
-#include "net/base/net_errors.h"
-#include "net/quic/quic_utils.h"
-
-namespace net {
-
-namespace {
-
-class QuicChromeAlarm : public QuicAlarm {
- public:
-  QuicChromeAlarm(const QuicClock* clock,
-                  base::TaskRunner* task_runner,
-                  QuicAlarm::Delegate* delegate)
-      : QuicAlarm(delegate),
-        clock_(clock),
-        task_runner_(task_runner),
-        task_deadline_(QuicTime::Zero()),
-        weak_factory_(this) {}
-
- protected:
-  void SetImpl() override {
-    DCHECK(deadline().IsInitialized());
-    if (task_deadline_.IsInitialized()) {
-      if (task_deadline_ <= deadline()) {
-        // Since tasks can not be un-posted, OnAlarm will be invoked which
-        // will notice that deadline has not yet been reached, and will set
-        // the alarm for the new deadline.
-        return;
-      }
-      // The scheduled task is after new deadline.  Invalidate the weak ptrs
-      // so that task does not execute when we're not expecting it.
-      weak_factory_.InvalidateWeakPtrs();
-    }
-
-    int64 delay_us = deadline().Subtract(clock_->Now()).ToMicroseconds();
-    if (delay_us < 0) {
-      delay_us = 0;
-    }
-    task_runner_->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&QuicChromeAlarm::OnAlarm, weak_factory_.GetWeakPtr()),
-        base::TimeDelta::FromMicroseconds(delay_us));
-    task_deadline_ = deadline();
-  }
-
-  void CancelImpl() override {
-    DCHECK(!deadline().IsInitialized());
-    // Since tasks can not be un-posted, OnAlarm will be invoked which
-    // will notice that deadline is not Initialized and will do nothing.
-  }
-
- private:
-  void OnAlarm() {
-    DCHECK(task_deadline_.IsInitialized());
-    task_deadline_ = QuicTime::Zero();
-    // The alarm may have been cancelled.
-    if (!deadline().IsInitialized()) {
-      return;
-    }
-
-    // The alarm may have been re-set to a later time.
-    if (clock_->Now() < deadline()) {
-      SetImpl();
-      return;
-    }
-
-    Fire();
-  }
-
-  const QuicClock* clock_;
-  base::TaskRunner* task_runner_;
-  // If a task has been posted to the message loop, this is the time it
-  // was scheduled to fire.  Tracking this allows us to avoid posting a
-  // new tast if the new deadline is in the future, but permits us to
-  // post a new task when the new deadline now earlier than when
-  // previously posted.
-  QuicTime task_deadline_;
-  base::WeakPtrFactory<QuicChromeAlarm> weak_factory_;
-};
-
-}  // namespace
-
-QuicConnectionHelper::QuicConnectionHelper(base::TaskRunner* task_runner,
-                                           const QuicClock* clock,
-                                           QuicRandom* random_generator)
-    : task_runner_(task_runner),
-      clock_(clock),
-      random_generator_(random_generator),
-      weak_factory_(this) {
-}
-
-QuicConnectionHelper::~QuicConnectionHelper() {
-}
-
-const QuicClock* QuicConnectionHelper::GetClock() const {
-  return clock_;
-}
-
-QuicRandom* QuicConnectionHelper::GetRandomGenerator() {
-  return random_generator_;
-}
-
-QuicAlarm* QuicConnectionHelper::CreateAlarm(QuicAlarm::Delegate* delegate) {
-  return new QuicChromeAlarm(clock_, task_runner_, delegate);
-}
-
-}  // namespace net