httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From j..@apache.org
Subject svn commit: r1591622 [20/33] - in /httpd/mod_spdy/trunk: ./ base/ base/base.xcodeproj/ base/metrics/ build/ build/all.xcodeproj/ build/build_util.xcodeproj/ build/install.xcodeproj/ build/internal/ build/linux/ build/mac/ build/util/ build/win/ install...
Date Thu, 01 May 2014 11:43:45 GMT
Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_hasher.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_hasher.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_hasher.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_hasher.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/mock_hasher.h"
+
+namespace net_instaweb {
+
+MockHasher::~MockHasher() {
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author:  morlovich@google.com (Maksim Orlovich)
+
+#include "net/instaweb/util/public/mock_message_handler.h"
+
+#include <cstdarg>
+#include <map>
+#include <utility>
+
+#include "base/scoped_ptr.h"
+#include "net/instaweb/util/public/abstract_mutex.h"
+#include "net/instaweb/util/public/google_message_handler.h"
+#include "net/instaweb/util/public/message_handler.h"
+#include "net/instaweb/util/public/thread_system.h"
+
+namespace net_instaweb {
+
+MockMessageHandler::MockMessageHandler() {
+  // TODO(morlovich): Allow providing the thread system as an argument.
+  scoped_ptr<ThreadSystem> thread_runtime(ThreadSystem::CreateThreadSystem());
+  mutex_.reset(thread_runtime->NewMutex());
+}
+
+MockMessageHandler::~MockMessageHandler() {
+}
+
+void MockMessageHandler::MessageVImpl(MessageType type,
+                                      const char* msg,
+                                      va_list args) {
+  ScopedMutex hold_mutex(mutex_.get());
+  GoogleMessageHandler::MessageVImpl(type, msg, args);
+  ++message_counts_[type];
+}
+
+void MockMessageHandler::FileMessageVImpl(MessageType type,
+                                          const char* filename, int line,
+                                          const char* msg, va_list args) {
+  ScopedMutex hold_mutex(mutex_.get());
+  GoogleMessageHandler::FileMessageVImpl(type, filename, line, msg, args);
+  ++message_counts_[type];
+}
+
+int MockMessageHandler::MessagesOfType(MessageType type) const {
+  ScopedMutex hold_mutex(mutex_.get());
+  return MessagesOfTypeImpl(type);
+}
+
+int MockMessageHandler::MessagesOfTypeImpl(MessageType type) const {
+  MessageCountMap::const_iterator i = message_counts_.find(type);
+  if (i != message_counts_.end()) {
+    return i->second;
+  } else {
+    return 0;
+  }
+}
+
+int MockMessageHandler::TotalMessages() const {
+  ScopedMutex hold_mutex(mutex_.get());
+  return TotalMessagesImpl();
+}
+
+int MockMessageHandler::TotalMessagesImpl() const {
+
+  int total = 0;
+  for (MessageCountMap::const_iterator i = message_counts_.begin();
+       i != message_counts_.end(); ++i) {
+    total += i->second;
+  }
+  return total;
+}
+
+int MockMessageHandler::SeriousMessages() const {
+  ScopedMutex hold_mutex(mutex_.get());
+  return TotalMessagesImpl() - MessagesOfTypeImpl(kInfo);
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_message_handler_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/mock_message_handler.h"
+#include "net/instaweb/util/public/message_handler.h"
+
+namespace net_instaweb {
+
+namespace {
+
+class MockMessageHandlerTest : public testing::Test {
+ protected:
+  void CheckCounts(int expectInfo, int expectWarn, int expectError,
+                   int expectFatal) {
+    EXPECT_EQ(expectInfo, handler_.MessagesOfType(kInfo));
+    EXPECT_EQ(expectWarn, handler_.MessagesOfType(kWarning));
+    EXPECT_EQ(expectError, handler_.MessagesOfType(kError));
+    EXPECT_EQ(expectFatal, handler_.MessagesOfType(kFatal));
+  }
+
+  MockMessageHandler handler_;
+};
+
+
+TEST_F(MockMessageHandlerTest, Simple) {
+  EXPECT_EQ(0, handler_.TotalMessages());
+  EXPECT_EQ(0, handler_.SeriousMessages());
+
+  handler_.Message(kInfo, "test info message");
+  EXPECT_EQ(1, handler_.TotalMessages());
+  EXPECT_EQ(0, handler_.SeriousMessages());
+  CheckCounts(1, 0, 0, 0);
+
+  handler_.Message(kWarning, "text warning message");
+  EXPECT_EQ(2, handler_.TotalMessages());
+  EXPECT_EQ(1, handler_.SeriousMessages());
+  CheckCounts(1, 1, 0, 0);
+
+  handler_.Message(kError, "text Error message");
+  EXPECT_EQ(3, handler_.TotalMessages());
+  EXPECT_EQ(2, handler_.SeriousMessages());
+  CheckCounts(1, 1, 1, 0);
+
+  // We can't actually test fatal, as it aborts
+  // TODO(morlovich) mock the fatal behavior so the test does not crash
+
+  handler_.Message(kInfo, "another test info message");
+  EXPECT_EQ(4, handler_.TotalMessages());
+  EXPECT_EQ(2, handler_.SeriousMessages());
+  CheckCounts(2, 1, 1, 0);
+}
+
+}  // namespace
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/mock_scheduler.h"
+
+#include "net/instaweb/util/public/abstract_mutex.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/mock_timer.h"
+#include "net/instaweb/util/public/scheduler.h"
+#include "net/instaweb/util/public/thread_system.h"
+#include "net/instaweb/util/public/timer.h"
+
+namespace net_instaweb {
+
+MockScheduler::MockScheduler(
+    ThreadSystem* thread_system, MockTimer* timer)
+    : Scheduler(thread_system, timer),
+      timer_(timer) {
+}
+
+MockScheduler::~MockScheduler() {
+}
+
+void MockScheduler::AwaitWakeupUntilUs(int64 wakeup_time_us) {
+  // AwaitWakeupUntilUs is used to effectively move simulated time forward
+  // during unit tests.  Various callbacks in the test infrastructure
+  // can be called as a result of Alarms firing, enabling the simulation of
+  // cache/http fetches with non-zero delay, compute-bound rewrites, or
+  // threaded rewrites.
+  //
+  // To make things simple and deterministic, we simply advance the
+  // time when the work threads quiesce.
+  if (QueuedWorkerPool::AreBusy(workers_) || running_waiting_alarms()) {
+    Scheduler::AwaitWakeupUntilUs(timer_->NowUs() + 10 * Timer::kMsUs);
+  } else {
+    // Can fire off alarms, so we have to be careful to have the lock
+    // relinquished.
+
+    mutex()->Unlock();
+    if (wakeup_time_us >= timer_->NowUs()) {
+      timer_->SetTimeUs(wakeup_time_us);
+    }
+    mutex()->Lock();
+  }
+}
+
+void MockScheduler::AwaitQuiescence() {
+  ScopedMutex lock(mutex());
+  while (QueuedWorkerPool::AreBusy(workers_) || running_waiting_alarms()) {
+    Scheduler::AwaitWakeupUntilUs(timer_->NowUs() + 10 * Timer::kMsUs);
+  }
+}
+
+void MockScheduler::RegisterWorker(QueuedWorkerPool::Sequence* w) {
+  ScopedMutex lock(mutex());
+  workers_.insert(w);
+}
+
+void MockScheduler::UnregisterWorker(QueuedWorkerPool::Sequence* w) {
+  ScopedMutex lock(mutex());
+  workers_.erase(w);
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_scheduler_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,73 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "base/scoped_ptr.h"
+#include "net/instaweb/util/public/abstract_mutex.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/function.h"
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/mock_scheduler.h"
+#include "net/instaweb/util/public/mock_timer.h"
+#include "net/instaweb/util/public/thread_system.h"
+#include "net/instaweb/util/public/timer.h"
+
+namespace net_instaweb {
+
+namespace {
+
+// Make the simulated times be very long just to show that we are in
+// mock time and don't need to wait a century for this test to finish.
+const int64 kDelayMs = 50 * Timer::kYearMs;
+const int64 kWaitMs = 100 * Timer::kYearMs;
+
+class Alarm : public Function {
+ public:
+  Alarm() {}
+  virtual void Run() { }
+};
+
+}  // namespace
+
+class MockSchedulerTest : public testing::Test {
+ protected:
+  MockSchedulerTest()
+      : timer_(0),
+        thread_system_(ThreadSystem::CreateThreadSystem()),
+        scheduler_(thread_system_.get(), &timer_) {
+  }
+
+ protected:
+  MockTimer timer_;
+  scoped_ptr<ThreadSystem> thread_system_;
+  MockScheduler scheduler_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockSchedulerTest);
+};
+
+TEST_F(MockSchedulerTest, WakeupOnAdvancementOfSimulatedTime) {
+  timer_.AddAlarm(1000 * kDelayMs, new Alarm());
+  {
+    ScopedMutex lock(scheduler_.mutex());
+    scheduler_.BlockingTimedWait(kWaitMs);
+
+    // The idle-callback will get run after 50 years, but TimedWait
+    // won't actually return until the full 100 years has passed.
+    EXPECT_EQ(kWaitMs, timer_.NowMs());
+  }
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: morlovich@google.com (Maksim Orlovich)
+//
+// Contains MockTimeCache, which lets one inject MockTimer-simulated
+// delays before callback invocations of a cache object, as well as
+// MockTimeCache::Callback, which chains to a passed-in callback to actually
+// implement the delay.
+
+#include "net/instaweb/util/public/mock_time_cache.h"
+
+#include "net/instaweb/util/public/function.h"
+#include "net/instaweb/util/public/mock_timer.h"
+#include "net/instaweb/util/public/shared_string.h"
+
+namespace net_instaweb {
+
+// This calls a passed-in callback with a mock time delay, forwarding
+// on lookup results.
+class MockTimeCache::DelayCallback : public CacheInterface::Callback {
+ public:
+  DelayCallback(MockTimeCache* parent, Callback* orig_callback)
+      : parent_(parent), orig_callback_(orig_callback) {}
+
+  virtual ~DelayCallback() {}
+
+  virtual void Done(KeyState state) {
+    *orig_callback_->value() = *value();
+
+    parent_->timer()->AddAlarm(
+        parent_->timer()->NowUs() + parent_->delay_us(),
+        new MemberFunction1<CacheInterface::Callback, CacheInterface::KeyState>(
+            &CacheInterface::Callback::Done, orig_callback_, state));
+    delete this;
+  };
+
+ private:
+  MockTimeCache* parent_;
+  Callback* orig_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelayCallback);
+};
+
+MockTimeCache::MockTimeCache(MockTimer* timer, CacheInterface* cache)
+    : timer_(timer), cache_(cache), delay_us_(0) {}
+
+MockTimeCache::~MockTimeCache() {}
+
+void MockTimeCache::Get(const GoogleString& key, Callback* callback) {
+  if (delay_us_ == 0) {
+    cache_->Get(key, callback);
+  } else {
+    cache_->Get(key, new DelayCallback(this, callback));
+  }
+}
+
+void MockTimeCache::Put(const GoogleString& key, SharedString* value) {
+  cache_->Put(key, value);
+}
+
+void MockTimeCache::Delete(const GoogleString& key) {
+  cache_->Delete(key);
+}
+
+}  // namespace net_instaweb
+

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_time_cache_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: morlovich@google.com (Maksim Orlovich)
+
+// Unit-test for MockTimeCache
+
+#include "net/instaweb/util/public/mock_time_cache.h"
+
+#include <cstddef>
+#include "net/instaweb/util/cache_test_base.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/lru_cache.h"
+#include "net/instaweb/util/public/mock_timer.h"
+#include "net/instaweb/util/public/shared_string.h"
+
+namespace net_instaweb {
+namespace {
+
+const size_t kMaxSize = 100;
+
+// We start time from a non-zero value to make sure we don't confuse
+// relative and absolute. The value itself is of no particular significance.
+const int64 kStartTime = 3456;
+
+class MockTimeCacheTest : public CacheTestBase {
+ protected:
+  MockTimeCacheTest()
+      : timer_(kStartTime), lru_cache_(kMaxSize), cache_(&timer_, &lru_cache_) {
+  }
+
+  virtual CacheInterface* Cache() { return &cache_; }
+
+ protected:
+  MockTimer timer_;
+  LRUCache lru_cache_;
+  MockTimeCache cache_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockTimeCacheTest);
+};
+
+TEST_F(MockTimeCacheTest, NoDelayOps) {
+  // Basic operation w/o any delay injected.
+  CheckNotFound("Name");
+  CheckPut("Name", "Value");
+  CheckGet("Name", "Value");
+  cache_.Delete("Name");
+  CheckNotFound("Name");
+}
+
+TEST_F(MockTimeCacheTest, DelayOps) {
+  const int64 kDelayUs = 10000;
+  cache_.set_delay_us(kDelayUs);
+
+  // Load the value.
+  CheckPut("Name", "Value");
+
+  // Try getting...
+  CacheTestBase::Callback result;
+  cache_.Get("Name", &result);
+
+  // Initially, should not have been called.
+  EXPECT_FALSE(result.called_);
+
+  // Move halfways to completion; should still have not been called.
+  timer_.AdvanceUs(kDelayUs / 2);
+  EXPECT_FALSE(result.called_);
+
+  // Now after it expires, it should be OK.
+  timer_.AdvanceUs(kDelayUs / 2 + 1);
+  EXPECT_TRUE(result.called_);
+  EXPECT_EQ(CacheInterface::kAvailable, result.state_);
+  EXPECT_EQ("Value", *result.value()->get());
+
+  // Do the same thing after deleting it.
+  cache_.Delete("Name");
+  cache_.Get("Name", result.Reset());
+  EXPECT_FALSE(result.called_);
+  timer_.AdvanceUs(kDelayUs / 2);
+  EXPECT_FALSE(result.called_);
+  timer_.AdvanceUs(kDelayUs / 2 + 1);
+  EXPECT_TRUE(result.called_);
+  EXPECT_EQ(CacheInterface::kNotFound, result.state_);
+}
+
+}  // namespace
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_timer.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_timer.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_timer.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_timer.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/mock_timer.h"
+
+#include <cstddef>
+#include <set>
+
+#include "base/logging.h"
+#include "base/scoped_ptr.h"
+#include "net/instaweb/util/public/abstract_mutex.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/function.h"
+#include "net/instaweb/util/public/null_mutex.h"
+
+namespace net_instaweb {
+
+const int64 MockTimer::kApr_5_2010_ms = 1270493486000LL;
+
+MockTimer::MockTimer(int64 time_ms)
+    : time_us_(1000 * time_ms),
+      next_index_(0),
+      mutex_(new NullMutex) {
+}
+
+MockTimer::~MockTimer() {
+  while (!alarms_.empty()) {
+    AlarmOrderedSet::iterator p = alarms_.begin();
+    Alarm* alarm = *p;
+    alarms_.erase(p);
+    alarm->CallCancel();
+  }
+}
+
+MockTimer::Alarm::Alarm(int64 wakeup_time_us, Function* closure)
+    : index_(kIndexUninitialized),
+      wakeup_time_us_(wakeup_time_us),
+      closure_(closure) {
+}
+
+MockTimer::Alarm::~Alarm() {
+  DCHECK(closure_ == NULL)
+      << "Must call CallRun or CallCancel before deleting Alarm";
+}
+
+int MockTimer::Alarm::Compare(const Alarm* that) const {
+  int cmp = 0;
+  if (wakeup_time_us_ < that->wakeup_time_us_) {
+    cmp = -1;
+  } else if (wakeup_time_us_ > that->wakeup_time_us_) {
+    cmp = 1;
+  } else if (index_ < that->index_) {
+    cmp = -1;
+  } else if (index_ > that->index_) {
+    cmp = 1;
+  }
+  return cmp;
+}
+
+void MockTimer::Alarm::SetIndex(int index) {
+  CHECK_EQ(kIndexUninitialized, index_);
+  index_ = index;
+}
+
+void MockTimer::Alarm::CallRun() {
+  closure_->CallRun();
+  closure_ = NULL;
+  delete this;
+}
+
+void MockTimer::Alarm::CallCancel() {
+  closure_->CallCancel();
+  closure_ = NULL;
+  delete this;
+}
+
+MockTimer::Alarm* MockTimer::AddAlarm(int64 wakeup_time_us, Function* closure) {
+  bool call_now = false;
+  Alarm* alarm = new Alarm(wakeup_time_us, closure);
+  {
+    ScopedMutex lock(mutex_.get());
+    if (time_us_ >= alarm->wakeup_time_us()) {
+      call_now = true;
+    } else {
+      alarm->SetIndex(next_index_++);
+      size_t prev_count = alarms_.size();
+      alarms_.insert(alarm);
+      CHECK_EQ(1 + prev_count, alarms_.size());
+    }
+    // Release lock before running potentially the Alarm.
+  }
+  if (call_now) {
+    alarm->CallRun();
+    alarm = NULL;
+  }
+  return alarm;
+}
+
+void MockTimer::CancelAlarm(Alarm* alarm) {
+  ScopedMutex lock(mutex_.get());
+  int erased = alarms_.erase(alarm);
+  if (erased == 1) {
+    alarm->CallCancel();
+  } else {
+    LOG(DFATAL) << "Canceled alarm not found";
+  }
+}
+
+void MockTimer::SetTimeUs(int64 new_time_us) {
+  mutex_->Lock();
+  while (!alarms_.empty()) {
+    AlarmOrderedSet::iterator p = alarms_.begin();
+    Alarm* alarm = *p;
+    int64 wakeup_us = alarm->wakeup_time_us();
+    if (new_time_us < wakeup_us) {
+      break;
+    } else {
+      alarms_.erase(p);
+      if (wakeup_us > time_us_) {
+        time_us_ = wakeup_us;
+      }
+      mutex_->Unlock();
+      alarm->CallRun();
+      mutex_->Lock();
+    }
+  }
+
+  // If an Alarm::Run function moved us forward in time, don't move us back.
+  if (time_us_ < new_time_us) {
+    time_us_ = new_time_us;
+  }
+  mutex_->Unlock();
+}
+
+int64 MockTimer::NowUs() const {
+  ScopedMutex(mutex_.get());
+  return time_us_;
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/mock_timer_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/mock_timer_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/mock_timer_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/mock_timer_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,164 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/mock_timer.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/function.h"
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/string.h"
+
+namespace net_instaweb {
+
+namespace {
+
+// This is an alarm implementation which adds new alarms and optionally advances
+// time in its callback.
+class ChainedAlarm : public Function {
+ public:
+  ChainedAlarm(MockTimer* timer, int* count, bool advance)
+    : timer_(timer),
+      count_(count) ,
+      advance_(advance) {}
+
+  virtual void Run() {
+    if (--*count_ > 0) {
+      timer_->AddAlarm(timer_->NowUs() + 100,
+                       new ChainedAlarm(timer_, count_, advance_));
+      if (advance_) {
+        timer_->AdvanceMs(100);
+      }
+    }
+  }
+
+ private:
+  MockTimer* timer_;
+  int* count_;
+  bool advance_;
+};
+
+}  // namespace
+
+class MockTimerTest : public testing::Test {
+ protected:
+  MockTimerTest()
+      : timer_(new MockTimer(0)),
+        was_run_(false),
+        was_cancelled_(false) {}
+
+  MockTimer::Alarm* AddTask(int64 wakeup_time_us, char c) {
+    Function* append_char = new MemberFunction1<GoogleString, char>(
+        &GoogleString::push_back, &string_, c);
+    return timer_->AddAlarm(wakeup_time_us, append_char);
+  }
+
+  void Run() {
+    was_run_ = true;
+  }
+
+  void Cancel() {
+    was_cancelled_ = true;
+  }
+
+  MockTimer::Alarm* AddRunCancelAlarm(int64 timeout_ms) {
+    MockTimerTest* mock_timer_test = this;  // Implicit upcast.
+    return timer_->AddAlarm(timeout_ms, new MemberFunction0<MockTimerTest>(
+        &MockTimerTest::Run, &MockTimerTest::Cancel, mock_timer_test));
+  }
+
+ protected:
+  scoped_ptr<MockTimer> timer_;
+  GoogleString string_;
+  bool was_run_;
+  bool was_cancelled_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockTimerTest);
+};
+
+TEST_F(MockTimerTest, ScheduleOrdering) {
+  AddTask(1, '1');
+  AddTask(3, '3');
+  AddTask(2, '2');
+  timer_->AdvanceUs(3);  // runs all 3 tasks
+  EXPECT_EQ("123", string_);
+}
+
+TEST_F(MockTimerTest, SchedulePartial) {
+  AddTask(5, '5');
+  AddTask(5, '6');  // same wakeup time, but order is preserved.
+  AddTask(6, '7');
+  AddTask(3, '3');
+  AddTask(2, '2');
+  AddTask(4, '4');
+  AddTask(1, '1');
+  timer_->AdvanceUs(3);  // runs first 3 tasks
+  EXPECT_EQ("123", string_);
+  string_.clear();
+  timer_->AdvanceUs(3);  // runs next 4 tasks
+  EXPECT_EQ("4567", string_);
+}
+
+TEST_F(MockTimerTest, Cancellation) {
+  AddTask(1, '1');
+  MockTimer::Alarm* alarm_to_cancel = AddTask(3, '3');
+  AddTask(2, '2');
+  AddTask(4, '4');
+  timer_->CancelAlarm(alarm_to_cancel);
+  timer_->AdvanceUs(4);  // runs the 3 tasks not canceled.
+  EXPECT_EQ("124", string_);
+}
+
+// Verifies that we can add a new alarm from an Alarm::Run() method.
+TEST_F(MockTimerTest, ChainedAlarms) {
+  int count = 10;
+  timer_->AddAlarm(100, new ChainedAlarm(timer_.get(), &count, false));
+  timer_->AdvanceMs(1000);
+  EXPECT_EQ(0, count);
+}
+
+// Verifies that we can advance time from an Alarm::Run() method.
+TEST_F(MockTimerTest, AdvanceFromRun) {
+  int count = 10;
+  timer_->AddAlarm(100, new ChainedAlarm(timer_.get(), &count, true));
+  timer_->AdvanceMs(100);
+  EXPECT_EQ(0, count);
+}
+
+TEST_F(MockTimerTest, RunNotCancelled) {
+  // First, let the alarm run normally.
+  AddRunCancelAlarm(100);
+  timer_->AdvanceUs(200);
+  EXPECT_TRUE(was_run_);
+  EXPECT_FALSE(was_cancelled_);
+}
+
+TEST_F(MockTimerTest, CancelledExplicitly) {
+  // Next cancel the alarm explicitly before it runs.
+  MockTimer::Alarm* alarm = AddRunCancelAlarm(500);
+  timer_->CancelAlarm(alarm);
+  EXPECT_FALSE(was_run_);
+  EXPECT_TRUE(was_cancelled_);
+}
+
+TEST_F(MockTimerTest, CancelledDueToMockTimerDestruction) {
+  // Finally, let the alarm be implicitly cancelled by deleting the timer.
+  AddRunCancelAlarm(500);
+  timer_.reset(NULL);
+  EXPECT_FALSE(was_run_);
+  EXPECT_TRUE(was_cancelled_);
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/named_lock_manager.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/named_lock_manager.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/named_lock_manager.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/named_lock_manager.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmaessen@google.com (Jan Maessen)
+
+#include "net/instaweb/util/public/named_lock_manager.h"
+
+namespace net_instaweb {
+
+NamedLock::~NamedLock() { }
+
+NamedLockManager::~NamedLockManager() { }
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/null_message_handler.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/null_message_handler.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/null_message_handler.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/null_message_handler.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: lsong@google.com (Libo Song)
+
+#include "net/instaweb/util/public/null_message_handler.h"
+
+#include <cstdarg>
+
+#include "net/instaweb/util/public/message_handler.h"
+
+namespace net_instaweb {
+
+NullMessageHandler::~NullMessageHandler() {
+}
+
+void NullMessageHandler::MessageVImpl(MessageType type, const char* msg,
+                                      va_list args) {
+}
+
+void NullMessageHandler::FileMessageVImpl(MessageType type, const char* file,
+                                          int line, const char* msg,
+                                          va_list args) {
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/null_mutex.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/null_mutex.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/null_mutex.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/null_mutex.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/null_mutex.h"
+
+namespace net_instaweb {
+
+NullMutex::~NullMutex() {
+}
+
+void NullMutex::Lock() {
+}
+
+void NullMutex::Unlock() {
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/null_statistics.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/null_statistics.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/null_statistics.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/null_statistics.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/null_statistics.h"
+#include "net/instaweb/util/public/string_util.h"
+
+namespace net_instaweb {
+
+NullStatisticsVariable::~NullStatisticsVariable() {
+}
+
+NullStatistics::~NullStatistics() {
+}
+
+NullStatisticsVariable* NullStatistics::NewVariable(
+    const StringPiece& name, int index) {
+  return new NullStatisticsVariable;
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/null_writer.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/null_writer.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/null_writer.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/null_writer.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/null_writer.h"
+#include "net/instaweb/util/public/string_util.h"
+
+namespace net_instaweb {
+class MessageHandler;
+
+NullWriter::~NullWriter() {
+}
+
+bool NullWriter::Write(const StringPiece& str, MessageHandler* handler) {
+  return true;
+}
+
+bool NullWriter::Flush(MessageHandler* handler) {
+  return true;
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pool_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pool_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pool_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pool_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,201 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jmaessen@google.com (Jan Maessen)
+
+#include "net/instaweb/util/public/pool.h"
+
+#include <list>
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/pool_element.h"
+#include "net/instaweb/util/public/string.h"
+
+namespace net_instaweb {
+
+namespace {
+
+// Pool element containing an int, for test purposes.
+class IntElement : public PoolElement<IntElement> {
+ public:
+  IntElement() { }
+
+  const int num() const { return num_; }
+  void set_num(int num) { num_ = num; }
+
+ private:
+  int num_;
+
+  DISALLOW_COPY_AND_ASSIGN(IntElement);
+};
+
+typedef Pool<IntElement> IntPool;
+typedef PoolElement<IntElement>::Position PoolPosition;
+
+class PoolTest : public testing::Test {
+ protected:
+  PoolTest() {
+    for (int i = 0; i < arraysize(elements_); ++i) {
+      elements_[i].set_num(i);
+    }
+  }
+
+  ~PoolTest() {
+    pool_.Clear();
+  }
+
+  // Add just the ith element to pool_
+  void Add(int i) {
+    int sz = pool_.size();
+    pool_.Add(&elements_[i]);
+    EXPECT_FALSE(pool_.empty());
+    EXPECT_EQ(sz + 1, pool_.size());
+  }
+
+  // Add the first n elements_ to pool_ for test setup.
+  void Adds(int n) {
+    for (int i = 0; i < n; ++i) {
+      Add(i);
+    }
+  }
+
+  // Expect that pool_ contains the n elements in expected, in order.
+  void ExpectContainsElements(int n, const int* expected) {
+    EXPECT_EQ(n, pool_.size());
+    PoolPosition iter = pool_.begin();
+    for (int i = 0; i < n; ++i) {
+      EXPECT_EQ(expected[i], (*iter)->num()) << "Actually " << Dump();
+      ++iter;
+    }
+  }
+
+  // Expect that pool_ contains the numbers in [lo,hi], in order.
+  void ExpectContains(int lo, int hi) {
+    EXPECT_EQ(hi - lo + 1, pool_.size());
+    IntPool::iterator iter = pool_.begin();
+    for (int i = lo; i <= hi; ++i) {
+      EXPECT_EQ(i, (*iter)->num()) << "Actually " << Dump();
+      ++iter;
+    }
+  }
+
+  // Expect that the next element removed will be i
+  void ExpectRemoveOldest(int i) {
+    int sz = pool_.size();
+    EXPECT_FALSE(pool_.empty());
+    IntElement* e = pool_.oldest();
+    EXPECT_EQ(i, e->num());
+    EXPECT_EQ(e, pool_.RemoveOldest());
+    EXPECT_EQ(sz - 1, pool_.size());
+  }
+
+  // Remove the element i from pool_
+  void Remove(int i) {
+    int sz = pool_.size();
+    EXPECT_FALSE(pool_.empty());
+    EXPECT_EQ(i, pool_.Remove(&elements_[i])->num());
+    EXPECT_EQ(sz - 1, pool_.size());
+  }
+
+  // Dump the pool value.  Yields, dirty, and compact string (but isn't robust
+  // if we were to use enormous pool sizes during testing; since we're backed by
+  // collections this should not be necessary).
+  GoogleString Dump() {
+    GoogleString buf;
+    for (IntPool::iterator iter = pool_.begin(); iter != pool_.end(); ++iter) {
+      buf.push_back((*iter)->num() + '0');
+    }
+    return buf;
+  }
+
+  IntPool pool_;
+  IntElement elements_[4];
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PoolTest);
+};
+
+TEST_F(PoolTest, TestInsertAndOrderedRemoveOldest) {
+  EXPECT_TRUE(pool_.empty());
+  EXPECT_EQ(0, pool_.size());
+  Adds(4);
+  ExpectContains(0, 3);
+  ExpectRemoveOldest(0);
+  ExpectRemoveOldest(1);
+  ExpectRemoveOldest(2);
+  ExpectRemoveOldest(3);
+  EXPECT_TRUE(pool_.empty());
+  EXPECT_TRUE(NULL == pool_.RemoveOldest());
+}
+
+TEST_F(PoolTest, TestInsertAndRemove) {
+  Adds(4);
+  ExpectContains(0, 3);
+  Remove(0);
+  ExpectContains(1, 3);
+  Remove(1);
+  ExpectContains(2, 3);
+  Remove(2);
+  ExpectContains(3, 3);
+  Remove(3);
+  EXPECT_TRUE(pool_.empty());
+}
+
+TEST_F(PoolTest, TestRemoveAndReinsertFront) {
+  Adds(4);
+  ExpectContains(0, 3);
+  Remove(3);
+  ExpectContains(0, 2);
+  Add(3);
+  ExpectContains(0, 3);
+}
+
+TEST_F(PoolTest, TestRemoveAndReinsertBack) {
+  Adds(4);
+  ExpectContains(0, 3);
+  Remove(0);
+  ExpectContains(1, 3);
+  Add(0);
+  ExpectRemoveOldest(1);
+  ExpectRemoveOldest(2);
+  ExpectRemoveOldest(3);
+  ExpectRemoveOldest(0);
+}
+
+TEST_F(PoolTest, TestRemoveAndReinsertMiddle) {
+  Adds(4);
+  ExpectContains(0, 3);
+  Remove(2);
+  const int kMiddleExpected[] = { 0, 1, 3 };
+  ExpectContainsElements(arraysize(kMiddleExpected), kMiddleExpected);
+  Add(2);
+  ExpectRemoveOldest(0);
+  ExpectRemoveOldest(1);
+  ExpectRemoveOldest(3);
+  ExpectRemoveOldest(2);
+}
+
+TEST_F(PoolTest, TestClear) {
+  Adds(4);
+  ExpectContains(0, 3);
+  pool_.Clear();
+  EXPECT_TRUE(pool_.empty());
+}
+
+TEST_F(PoolTest, OldestEmpty) {
+  EXPECT_TRUE(NULL == pool_.oldest());
+}
+
+}  // namespace
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,73 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jmaessen@google.com (Jan Maessen)
+
+#include "net/instaweb/util/public/pthread_condvar.h"
+
+#include <pthread.h>
+#include <sys/time.h>
+#include <cerrno>
+#include <ctime>
+
+#include "base/logging.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/pthread_mutex.h"
+#include "net/instaweb/util/public/timer.h"
+
+namespace net_instaweb {
+
+PthreadCondvar::~PthreadCondvar() {
+  pthread_cond_destroy(&condvar_);
+}
+
+void PthreadCondvar::Signal() {
+  pthread_cond_signal(&condvar_);
+}
+
+void PthreadCondvar::Broadcast() {
+  pthread_cond_broadcast(&condvar_);
+}
+
+void PthreadCondvar::Wait() {
+  pthread_cond_wait(&condvar_, &mutex_->mutex_);
+}
+
+void PthreadCondvar::TimedWait(int64 timeout_ms) {
+  const int64 kMsNs = Timer::kSecondNs / Timer::kSecondMs;
+  struct timespec timeout;
+  struct timeval current_time;
+  // convert timeout_ms to seconds and ms
+  int64 timeout_sec_incr = timeout_ms / Timer::kSecondMs;
+  timeout_ms %= Timer::kSecondMs;
+  // Figure out current time, compute absolute time for timeout
+  // Carrying ns to s as appropriate.  As morlovich notes, we
+  // get *really close* to overflowing a 32-bit tv_nsec here,
+  // so this code should be modified with caution.
+  if (gettimeofday(&current_time, NULL) != 0) {
+    LOG(FATAL) << "Could not determine time of day";
+  }
+  timeout.tv_nsec = current_time.tv_usec * 1000 + timeout_ms * kMsNs;
+  timeout_sec_incr += timeout.tv_nsec / Timer::kSecondNs;
+  timeout.tv_nsec %= Timer::kSecondNs;
+  timeout.tv_sec = current_time.tv_sec + static_cast<time_t>(timeout_sec_incr);
+  // Finally we actually get to wait.
+  pthread_cond_timedwait(&condvar_, &mutex_->mutex_, &timeout);
+}
+
+void PthreadCondvar::Init() {
+  while (pthread_cond_init(&condvar_, NULL) == EAGAIN) { }
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_condvar_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,103 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jmaessen@google.com (Jan Maessen)
+
+#include "net/instaweb/util/public/pthread_condvar.h"
+
+#include <pthread.h>
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/condvar.h"
+#include "net/instaweb/util/public/condvar_test_base.h"
+#include "net/instaweb/util/public/google_timer.h"
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/pthread_mutex.h"
+#include "net/instaweb/util/public/thread_system.h"
+
+namespace net_instaweb {
+class Timer;
+
+class PthreadCondvarTest : public CondvarTestBase {
+ protected:
+  PthreadCondvarTest()
+      : pthread_mutex_(),
+        pthread_startup_condvar_(&pthread_mutex_),
+        pthread_condvar_(&pthread_mutex_) {
+    Init(&pthread_mutex_, &pthread_startup_condvar_, &pthread_condvar_);
+  }
+
+  virtual void CreateHelper() {
+    pthread_create(&helper_thread_, NULL,
+                   &HelperThread, this);
+  }
+
+  virtual void FinishHelper() {
+    pthread_join(helper_thread_, NULL);
+  }
+
+  virtual Timer* timer() { return &timer_; }
+
+  PthreadMutex pthread_mutex_;
+  PthreadCondvar pthread_startup_condvar_;
+  PthreadCondvar pthread_condvar_;
+  pthread_t helper_thread_;
+  GoogleTimer timer_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PthreadCondvarTest);
+};
+
+TEST_F(PthreadCondvarTest, TestStartup) {
+  StartupTest();
+}
+
+TEST_F(PthreadCondvarTest, BlindSignals) {
+  BlindSignalsTest();
+}
+
+TEST_F(PthreadCondvarTest, BroadcastBlindSignals) {
+  signal_method_ = &ThreadSystem::Condvar::Broadcast;
+  BlindSignalsTest();
+}
+
+TEST_F(PthreadCondvarTest, TestPingPong) {
+  PingPongTest();
+}
+
+TEST_F(PthreadCondvarTest, BroadcastTestPingPong) {
+  signal_method_ = &ThreadSystem::Condvar::Broadcast;
+  PingPongTest();
+}
+
+TEST_F(PthreadCondvarTest, TestTimeout) {
+  TimeoutTest();
+}
+
+TEST_F(PthreadCondvarTest, TestLongTimeout1200) {
+  // We pick a value over a second because the implementation special-cases
+  // that situation.
+  LongTimeoutTest(1100);
+  LongTimeoutTest(100);
+}
+
+TEST_F(PthreadCondvarTest, TimeoutPingPong) {
+  TimeoutPingPongTest();
+}
+
+TEST_F(PthreadCondvarTest, BroadcastTimeoutPingPong) {
+  signal_method_ = &ThreadSystem::Condvar::Broadcast;
+  TimeoutPingPongTest();
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_mutex.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_mutex.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_mutex.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_mutex.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#include "net/instaweb/util/public/pthread_mutex.h"
+
+#include <pthread.h>
+#include "net/instaweb/util/public/pthread_condvar.h"
+#include "net/instaweb/util/public/thread_system.h"
+
+namespace net_instaweb {
+
+PthreadMutex::PthreadMutex() {
+  pthread_mutex_init(&mutex_, NULL);
+}
+
+PthreadMutex::~PthreadMutex() {
+  pthread_mutex_destroy(&mutex_);
+}
+
+void PthreadMutex::Lock() {
+  pthread_mutex_lock(&mutex_);
+}
+
+void PthreadMutex::Unlock() {
+  pthread_mutex_unlock(&mutex_);
+}
+
+ThreadSystem::Condvar* PthreadMutex::NewCondvar() {
+  return new PthreadCondvar(this);
+}
+
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_rw_lock.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_rw_lock.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_rw_lock.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_rw_lock.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: pulkitg@google.com (Pulkit Goyal)
+
+#include "net/instaweb/util/public/pthread_rw_lock.h"
+
+#include <pthread.h>
+
+namespace net_instaweb {
+
+PthreadRWLock::PthreadRWLock() {
+  pthread_rwlockattr_init(&attr_);
+  // New writer lock call is given preference over existing reader lock calls,
+  // so that writer lock call will never get starved. However, it is not allowed
+  // if there exists any recursive reader lock call to prevent deadlocks.
+  pthread_rwlockattr_setkind_np(&attr_,
+                                PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
+  pthread_rwlock_init(&rwlock_, &attr_);
+}
+
+PthreadRWLock::~PthreadRWLock() {
+  pthread_rwlockattr_destroy(&attr_);
+  pthread_rwlock_destroy(&rwlock_);
+}
+
+void PthreadRWLock::Lock() {
+  pthread_rwlock_wrlock(&rwlock_);
+}
+
+void PthreadRWLock::Unlock() {
+  pthread_rwlock_unlock(&rwlock_);
+}
+
+void PthreadRWLock::ReaderLock() {
+  pthread_rwlock_rdlock(&rwlock_);
+}
+
+void PthreadRWLock::ReaderUnlock() {
+  pthread_rwlock_unlock(&rwlock_);
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,223 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#include "net/instaweb/util/public/pthread_shared_mem.h"
+
+#include <fcntl.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstddef>
+#include <map>
+#include <utility>
+#include "net/instaweb/util/public/abstract_shared_mem.h"
+#include "net/instaweb/util/public/abstract_mutex.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/message_handler.h"
+#include "net/instaweb/util/public/string.h"
+
+namespace net_instaweb {
+
+namespace {
+
+// This implementation relies on readonly copies of old memory and shared R/W
+// mappings being kept across a fork. It simply stashes addresses of
+// shared mmap segments into a map where kid processes can pick them up.
+
+// close() a fd logging failure and dealing with EINTR.
+void CheckedClose(int fd, MessageHandler* message_handler) {
+  while (close(fd) != 0) {
+    if (errno != EINTR) {
+      message_handler->Message(kWarning, "Problem closing SHM segment fd:%d",
+                               errno);
+      return;
+    }
+  }
+}
+
+// Unlike PthreadMutex this doesn't own the lock, but rather refers to an
+// external one.
+class PthreadSharedMemMutex : public AbstractMutex {
+ public:
+  explicit PthreadSharedMemMutex(pthread_mutex_t* external_mutex)
+      : external_mutex_(external_mutex) {}
+
+  virtual void Lock() {
+    pthread_mutex_lock(external_mutex_);
+  }
+
+  virtual void Unlock() {
+    pthread_mutex_unlock(external_mutex_);
+  }
+
+ private:
+  pthread_mutex_t* external_mutex_;
+
+  DISALLOW_COPY_AND_ASSIGN(PthreadSharedMemMutex);
+};
+
+class PthreadSharedMemSegment : public AbstractSharedMemSegment {
+ public:
+  // We will be representing memory mapped in the [base, base + size) range.
+  PthreadSharedMemSegment(char* base, size_t size, MessageHandler* handler)
+      : base_(base),
+        size_(size) {
+  }
+
+  virtual ~PthreadSharedMemSegment() {
+  }
+
+  virtual volatile char* Base() {
+    return base_;
+  }
+
+  virtual size_t SharedMutexSize() const {
+    return sizeof(pthread_mutex_t);
+  }
+
+  virtual bool InitializeSharedMutex(size_t offset, MessageHandler* handler) {
+    pthread_mutexattr_t attr;
+    if (pthread_mutexattr_init(&attr) != 0) {
+      handler->Message(kError, "pthread_mutexattr_init failed with errno:%d",
+                       errno);
+      return false;
+    }
+
+    if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED) != 0) {
+      pthread_mutexattr_destroy(&attr);
+      handler->Message(
+          kError, "pthread_mutexattr_setpshared failed with errno:%d", errno);
+      return false;
+    }
+
+    if (pthread_mutex_init(MutexPtr(offset), &attr) != 0) {
+      pthread_mutexattr_destroy(&attr);
+      handler->Message(kError, "pthread_mutex_init failed with errno:%d",
+                       errno);
+      return false;
+    }
+
+    pthread_mutexattr_destroy(&attr);
+    return true;
+  }
+
+  virtual AbstractMutex* AttachToSharedMutex(size_t offset) {
+    return new PthreadSharedMemMutex(MutexPtr(offset));
+  }
+
+ private:
+  pthread_mutex_t* MutexPtr(size_t offset) {
+    return reinterpret_cast<pthread_mutex_t*>(base_ + offset);
+  }
+
+  char* const base_;
+  const size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(PthreadSharedMemSegment);
+};
+
+pthread_mutex_t segment_bases_lock = PTHREAD_MUTEX_INITIALIZER;
+
+}  // namespace
+
+PthreadSharedMem::SegmentBaseMap* PthreadSharedMem::segment_bases_ = NULL;
+
+PthreadSharedMem::PthreadSharedMem() {
+}
+
+PthreadSharedMem::~PthreadSharedMem() {
+}
+
+size_t PthreadSharedMem::SharedMutexSize() const {
+  return sizeof(pthread_mutex_t);
+}
+
+AbstractSharedMemSegment* PthreadSharedMem::CreateSegment(
+    const GoogleString& name, size_t size, MessageHandler* handler) {
+  // Create the memory
+  int fd = open("/dev/zero", O_RDWR);
+  if (fd == -1) {
+    handler->Message(kError, "Unable to create SHM segment %s, errno=%d.",
+                     name.c_str(), errno);
+    return NULL;
+  }
+
+  // map it
+  char* base = reinterpret_cast<char*>(
+                   mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+  CheckedClose(fd, handler);
+  if (base == MAP_FAILED) {
+    return NULL;
+  }
+
+  SegmentBaseMap* bases = AcquireSegmentBases();
+  (*bases)[name] = base;
+  UnlockSegmentBases();
+  return new PthreadSharedMemSegment(base, size, handler);
+}
+
+AbstractSharedMemSegment* PthreadSharedMem::AttachToSegment(
+    const GoogleString& name, size_t size, MessageHandler* handler) {
+  SegmentBaseMap* bases = AcquireSegmentBases();
+  SegmentBaseMap::const_iterator i = bases->find(name);
+  if (i == bases->end()) {
+    handler->Message(kError, "Unable to find SHM segment %s to attach to.",
+                     name.c_str());
+    UnlockSegmentBases();
+    return NULL;
+  }
+  char* base = i->second;
+  UnlockSegmentBases();
+  return new PthreadSharedMemSegment(base, size, handler);
+}
+
+void PthreadSharedMem::DestroySegment(const GoogleString& name,
+                                      MessageHandler* handler) {
+  // Note that in the process state children will not see any mutations
+  // we make here, so it acts mostly for checking in that case.
+  SegmentBaseMap* bases = AcquireSegmentBases();
+  SegmentBaseMap::iterator i = bases->find(name);
+  if (i != bases->end()) {
+    bases->erase(i);
+    if (bases->empty()) {
+      delete segment_bases_;
+      segment_bases_ = NULL;
+    }
+  } else {
+    handler->Message(kError, "Attempt to destroy unknown SHM segment %s.",
+                     name.c_str());
+  }
+  UnlockSegmentBases();
+}
+
+PthreadSharedMem::SegmentBaseMap* PthreadSharedMem::AcquireSegmentBases() {
+  PthreadSharedMemMutex lock(&segment_bases_lock);
+  lock.Lock();
+
+  if (segment_bases_ == NULL) {
+    segment_bases_ = new SegmentBaseMap();
+  }
+
+  return segment_bases_;
+}
+
+void  PthreadSharedMem::UnlockSegmentBases() {
+  PthreadSharedMemMutex lock(&segment_bases_lock);
+  lock.Unlock();
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_shared_mem_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,160 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include <cstddef>
+#include <cstdlib>
+#include <vector>
+
+#include "net/instaweb/util/public/function.h"
+#include "net/instaweb/util/public/gtest.h"
+#include "net/instaweb/util/public/pthread_shared_mem.h"
+#include "net/instaweb/util/public/shared_circular_buffer_test_base.h"
+#include "net/instaweb/util/public/shared_dynamic_string_map_test_base.h"
+#include "net/instaweb/util/public/shared_mem_lock_manager_test_base.h"
+#include "net/instaweb/util/public/shared_mem_referer_statistics_test_base.h"
+#include "net/instaweb/util/public/shared_mem_statistics_test_base.h"
+#include "net/instaweb/util/public/shared_mem_test_base.h"
+
+namespace net_instaweb {
+class AbstractSharedMem;
+
+namespace {
+
+// We test operation of pthread shared memory with both thread & process
+// use, which is what PthreadSharedMemThreadEnv and PthreadSharedMemProcEnv
+// provide.
+
+class PthreadSharedMemEnvBase : public SharedMemTestEnv {
+ public:
+  virtual AbstractSharedMem* CreateSharedMemRuntime() {
+    return new PthreadSharedMem();
+  }
+
+  virtual void ShortSleep() {
+    usleep(1000);
+  }
+};
+
+class PthreadSharedMemThreadEnv : public PthreadSharedMemEnvBase {
+ public:
+  virtual bool CreateChild(Function* callback) {
+    pthread_t thread;
+    if (pthread_create(&thread, NULL, InvokeCallback, callback) != 0) {
+      return false;
+    }
+    child_threads_.push_back(thread);
+    return true;
+  }
+
+  virtual void WaitForChildren() {
+    for (size_t i = 0; i < child_threads_.size(); ++i) {
+      void* result = this;  // non-NULL -> failure.
+      EXPECT_EQ(0, pthread_join(child_threads_[i], &result));
+      EXPECT_EQ(NULL, result) << "Child reported failure";
+    }
+    child_threads_.clear();
+  }
+
+  virtual void ChildFailed() {
+    // In case of failure, we exit the thread with a non-NULL status.
+    // We leak the callback object in that case, but this only gets called
+    // for test failures anyway.
+    pthread_exit(this);
+  }
+
+ private:
+  static void* InvokeCallback(void* raw_callback_ptr) {
+    Function* callback = static_cast<Function*>(raw_callback_ptr);
+    callback->CallRun();
+    return NULL;  // Used to denote success
+  }
+
+  std::vector<pthread_t> child_threads_;
+};
+
+class PthreadSharedMemProcEnv : public PthreadSharedMemEnvBase {
+ public:
+  virtual bool CreateChild(Function* callback) {
+    pid_t ret = fork();
+    if (ret == -1) {
+      // Failure
+      callback->CallCancel();
+      return false;
+    } else if (ret == 0) {
+      // Child.
+      callback->CallRun();
+      std::exit(0);
+    } else {
+      // Parent.
+      child_processes_.push_back(ret);
+      callback->CallCancel();
+      return true;
+    }
+  }
+
+  virtual void WaitForChildren() {
+    for (size_t i = 0; i < child_processes_.size(); ++i) {
+      int status;
+      EXPECT_EQ(child_processes_[i], waitpid(child_processes_[i], &status, 0));
+      EXPECT_TRUE(WIFEXITED(status)) << "Child did not exit cleanly";
+      EXPECT_EQ(0, WEXITSTATUS(status)) << "Child reported failure";
+    }
+    child_processes_.clear();
+  }
+
+  virtual void ChildFailed() {
+    exit(-1);
+  }
+
+ private:
+  std::vector<pid_t> child_processes_;
+};
+
+
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadProc, SharedCircularBufferTestTemplate,
+                              PthreadSharedMemProcEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadProc, SharedDynamicStringMapTestTemplate,
+                              PthreadSharedMemProcEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadProc, SharedMemLockManagerTestTemplate,
+                              PthreadSharedMemProcEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadProc,
+                              SharedMemRefererStatisticsTestTemplate,
+                              PthreadSharedMemProcEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadProc, SharedMemStatisticsTestTemplate,
+                              PthreadSharedMemProcEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadProc, SharedMemTestTemplate,
+                              PthreadSharedMemProcEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread, SharedCircularBufferTestTemplate,
+                              PthreadSharedMemThreadEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread, SharedDynamicStringMapTestTemplate,
+                              PthreadSharedMemThreadEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread, SharedMemLockManagerTestTemplate,
+                              PthreadSharedMemThreadEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread,
+                              SharedMemRefererStatisticsTestTemplate,
+                              PthreadSharedMemThreadEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread, SharedMemStatisticsTestTemplate,
+                              PthreadSharedMemThreadEnv);
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread, SharedMemTestTemplate,
+                              PthreadSharedMemThreadEnv);
+
+}  // namespace
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#include "net/instaweb/util/public/pthread_thread_system.h"
+
+#include <pthread.h>
+
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/pthread_rw_lock.h"
+#include "net/instaweb/util/public/pthread_mutex.h"
+#include "net/instaweb/util/public/thread.h"
+#include "net/instaweb/util/public/thread_system.h"
+
+namespace net_instaweb {
+
+class PthreadThreadImpl : public ThreadSystem::ThreadImpl {
+ public:
+  PthreadThreadImpl(PthreadThreadSystem* thread_system,
+                    ThreadSystem::Thread* wrapper,
+                    ThreadSystem::ThreadFlags flags)
+      : thread_system_(thread_system),
+        wrapper_(wrapper),
+        flags_(flags) {
+  }
+
+  virtual ~PthreadThreadImpl() {
+  }
+
+  virtual bool StartImpl() {
+    int result;
+
+    pthread_attr_t attr;
+    result = pthread_attr_init(&attr);
+    if (result != 0) {
+      return false;
+    }
+
+    int mode = PTHREAD_CREATE_DETACHED;
+    if ((flags_ & ThreadSystem::kJoinable) != 0) {
+      mode = PTHREAD_CREATE_JOINABLE;
+    }
+
+    result = pthread_attr_setdetachstate(&attr, mode);
+    if (result != 0) {
+      return false;
+    }
+
+    result = pthread_create(&thread_obj_, &attr, InvokeRun, this);
+    if (result != 0) {
+      return false;
+    }
+
+    pthread_attr_destroy(&attr);
+    return true;
+  }
+
+  virtual void JoinImpl() {
+    void* ignored;
+    pthread_join(thread_obj_, &ignored);
+  }
+
+ private:
+  static void* InvokeRun(void* self_ptr) {
+    PthreadThreadImpl* self = static_cast<PthreadThreadImpl*>(self_ptr);
+    self->thread_system_->BeforeThreadRunHook();
+    self->wrapper_->Run();
+    return NULL;
+  }
+
+  PthreadThreadSystem* thread_system_;
+  ThreadSystem::Thread* wrapper_;
+  ThreadSystem::ThreadFlags flags_;
+  pthread_t thread_obj_;
+
+  DISALLOW_COPY_AND_ASSIGN(PthreadThreadImpl);
+};
+
+PthreadThreadSystem::PthreadThreadSystem() {
+}
+
+PthreadThreadSystem::~PthreadThreadSystem() {
+}
+
+ThreadSystem::CondvarCapableMutex* PthreadThreadSystem::NewMutex() {
+  return new PthreadMutex;
+}
+
+ThreadSystem::RWLock* PthreadThreadSystem::NewRWLock() {
+  return new PthreadRWLock;
+}
+
+void PthreadThreadSystem::BeforeThreadRunHook() {
+}
+
+ThreadSystem::ThreadImpl* PthreadThreadSystem::NewThreadImpl(
+    ThreadSystem::Thread* wrapper, ThreadSystem::ThreadFlags flags) {
+  return new PthreadThreadImpl(this, wrapper, flags);
+}
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system_test.cc
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system_test.cc?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system_test.cc (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/pthread_thread_system_test.cc Thu May  1 11:43:36 2014
@@ -0,0 +1,30 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#include "net/instaweb/util/thread_system_test_base.h"
+#include "net/instaweb/util/public/pthread_thread_system.h"
+#include "net/instaweb/util/public/gtest.h"
+
+namespace net_instaweb {
+
+namespace {
+
+INSTANTIATE_TYPED_TEST_CASE_P(PthreadThread, ThreadSystemTestTemplate,
+                              PthreadThreadSystem);
+
+}  // namespace
+
+}  // namespace net_instaweb

Added: httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_mutex.h
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_mutex.h?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_mutex.h (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_mutex.h Thu May  1 11:43:36 2014
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#ifndef NET_INSTAWEB_UTIL_PUBLIC_ABSTRACT_MUTEX_H_
+#define NET_INSTAWEB_UTIL_PUBLIC_ABSTRACT_MUTEX_H_
+
+#include "net/instaweb/util/public/basictypes.h"
+
+namespace net_instaweb {
+
+// Abstract interface for implementing a mutex.
+class AbstractMutex {
+ public:
+  virtual ~AbstractMutex();
+  virtual void Lock() = 0;
+  virtual void Unlock() = 0;
+  // Optionally checks that lock is held (for invariant checking purposes).
+  // Default implementation does no checking.
+  virtual void DCheckLocked();
+};
+
+// Helper class for lexically scoped mutexing.
+class ScopedMutex {
+ public:
+  explicit ScopedMutex(AbstractMutex* mutex) : mutex_(mutex) {
+    mutex_->Lock();
+  }
+
+  void Release() {
+    if (mutex_ != NULL) {
+      mutex_->Unlock();
+      mutex_ = NULL;
+    }
+  }
+
+  ~ScopedMutex() {
+    Release();
+  }
+
+ private:
+  AbstractMutex* mutex_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedMutex);
+};
+
+}  // namespace net_instaweb
+
+#endif  // NET_INSTAWEB_UTIL_PUBLIC_ABSTRACT_MUTEX_H_

Propchange: httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_mutex.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_shared_mem.h
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_shared_mem.h?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_shared_mem.h (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_shared_mem.h Thu May  1 11:43:36 2014
@@ -0,0 +1,120 @@
+// Copyright 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#ifndef NET_INSTAWEB_UTIL_PUBLIC_ABSTRACT_SHARED_MEM_H_
+#define NET_INSTAWEB_UTIL_PUBLIC_ABSTRACT_SHARED_MEM_H_
+
+#include <cstddef>
+#include "net/instaweb/util/public/abstract_mutex.h"
+#include "net/instaweb/util/public/basictypes.h"
+#include "net/instaweb/util/public/string.h"
+
+namespace net_instaweb {
+
+class MessageHandler;
+
+// This represents a region of memory shared between between multiple processes
+// that may contain mutexes.
+class AbstractSharedMemSegment {
+ public:
+  AbstractSharedMemSegment() {}
+
+  // Destroying the segment object detaches from it, making all pointers into it
+  // invalid.
+  virtual ~AbstractSharedMemSegment();
+
+  // Returns the base address of the segment. Note that there is no guarantee
+  // that this address will be the same for other processes attached to the
+  // same segment.
+  virtual volatile char* Base() = 0;
+
+  // This returns the number of bytes a mutex inside shared memory
+  // takes.
+  virtual size_t SharedMutexSize() const = 0;
+
+  // To use a mutex in shared memory, you first need to dedicate some
+  // [offset, offset + SharedMutexSize()) chunk of memory to it. Then,
+  // exactly one process must call InitializeSharedMutex(offset), and
+  // all users must call AttachToSharedMutex(offset) afterwards.
+  //
+  // InitializeSharedMutex returns whether it succeeded or not.
+  // AttachToSharedMutex returns a fresh object, giving ownership
+  // to the caller. The object returned is outside shared memory,
+  // and acts a helper for referring to the shared state.
+  virtual bool InitializeSharedMutex(size_t offset,
+                                     MessageHandler* handler) = 0;
+  virtual AbstractMutex* AttachToSharedMutex(size_t offset) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AbstractSharedMemSegment);
+};
+
+// Interface for creating and attaching to named shared memory segments.
+// The expectation is that whichever implementation is used at runtime
+// will be able to handle the combination of threads & processes used by
+// the hosting environment.
+//
+// The basic flow here is as follows:
+//
+//            Single process/thread startup stage:
+//            CreateSegment
+//            InitializeSharedMutex -----+
+//           /                           |
+//          /                            |
+//    process/thread:                   process/thread:
+//    AttachToSegment                   AttachToSegment
+//    AttachToSharedMutex               AttachToSharedMutex
+//       |                                     |
+//       |                                     |
+//       |------------------------------------/
+//       |
+//    single process/thread cleanup stage:
+//    DestroySegment
+//
+class AbstractSharedMem {
+ public:
+  AbstractSharedMem() {}
+  virtual ~AbstractSharedMem();
+
+  // Size of mutexes inside shared memory segments.
+  virtual size_t SharedMutexSize() const = 0;
+
+  // This should be called upon main process/thread initialization to create
+  // a shared memory segment that will be accessed by other processes/threads
+  // as identified by a unique name (via AttachToSegment). It will remove
+  // any previous segment with the same name. The memory will be zeroed out.
+  //
+  // May return NULL on failure.
+  virtual AbstractSharedMemSegment* CreateSegment(
+      const GoogleString& name, size_t size, MessageHandler* handler) = 0;
+
+  // Attaches to an existing segment, which must have been created already.
+  // May return NULL on failure
+  virtual AbstractSharedMemSegment* AttachToSegment(
+      const GoogleString& name, size_t size, MessageHandler* handler) = 0;
+
+  // Cleans up the segment with given name. You should call this after there is
+  // no longer any need for AttachToSegment to succeed.
+  virtual void DestroySegment(const GoogleString& name,
+                              MessageHandler* handler) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AbstractSharedMem);
+};
+
+}  // namespace net_instaweb
+
+#endif  // NET_INSTAWEB_UTIL_PUBLIC_ABSTRACT_SHARED_MEM_H_

Propchange: httpd/mod_spdy/trunk/net/instaweb/util/public/abstract_shared_mem.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: httpd/mod_spdy/trunk/net/instaweb/util/public/arena.h
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/public/arena.h?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/public/arena.h (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/public/arena.h Thu May  1 11:43:36 2014
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#ifndef NET_INSTAWEB_UTIL_PUBLIC_ARENA_H_
+#define NET_INSTAWEB_UTIL_PUBLIC_ARENA_H_
+
+#include <vector>
+#include <cstddef>
+
+#include "base/logging.h"
+#include "net/instaweb/util/public/basictypes.h"
+
+namespace net_instaweb {
+
+// This template keeps a packed set of objects inheriting from the same base
+// type (which must have a virtual destructor) where all of the
+// objects in the same arena are expected to be destroyed at once.
+template<typename T>
+class Arena {
+ public:
+  // All allocations we make will be aligned to this. We will also reserve
+  // this much room for our work area, as it keeps things simple.
+  static const size_t kAlign = 8;
+
+  Arena() {
+    InitEmpty();
+  }
+
+  ~Arena() {
+    CHECK(chunks_.empty());
+  }
+
+  void* Allocate(size_t size) {
+    size += kAlign;  // Need room to link the next object.
+    size = ExpandToAlign(size);
+
+    DCHECK(sizeof(void*) <= kAlign);
+    DCHECK(size < Chunk::kSize);
+
+    if (next_alloc_ + size > chunk_end_) {
+      AddChunk();
+    }
+
+    char* base = next_alloc_;
+
+    // Update the links -- the previous object should point to our
+    // chunk's base, our base should point to NULL, and last_link_
+    // should point to our base
+    char** our_last_link_field = reinterpret_cast<char**>(base);
+    *last_link_ = base;
+    *our_last_link_field = NULL;
+    last_link_ = our_last_link_field;
+
+    next_alloc_ += size;
+
+    char* out = base + kAlign;
+    DCHECK((reinterpret_cast<uintptr_t>(out) & (kAlign - 1)) == 0);
+    return out;
+  }
+
+  // Cleans up all the objects in the arena. You must call this explicitly.
+  void DestroyObjects();
+
+  // Rounds block size up to 8; we always align to it, even on 32-bit.
+  static size_t ExpandToAlign(size_t in) {
+    return (in + kAlign - 1) & ~(kAlign - 1);
+  }
+
+ private:
+  struct Chunk {
+    // Representation: the arena is a vector of fixed-size (kSize, 8k) chunks;
+    // we allocate objects from the end of the most recently created chunk until
+    // an allocation doesn't fit (in which case we make a fresh chunk)
+    //
+    // Each chunk is independently organized into a singly-linked list, where
+    // we precede each object with a pointer to the next allocated block, e.g.:
+    //
+    //                  /-----------------|
+    //                  |                \|/
+    // -----------------|---------------|----|-----------|
+    // |   | object 1 | | | object 2    | NU | object 3  |
+    // | | |          |   |             | LL |           |
+    // |_|_|----------|---|-------------|----|-----------|
+    //   |              ^
+    //   \--------------/
+    // We need this because objects may have different sizes, and we'll need
+    // to find everyone to call their destructor
+    static const size_t kSize = 8192;
+    char buf[kSize];
+  };
+
+  // Adds in a new chunk and initializes all the fields below to refer to it
+  void AddChunk();
+
+  // Sets up all the pointers below to denote us being empty.
+  void InitEmpty();
+
+  // First free byte of the current chunk
+  char* next_alloc_;
+
+  // The point where to link in a new object we allocate.
+  // We need this so that the last object in a chunk has
+  // a null 'next' link.
+  char** last_link_;
+
+  // First address after the last byte of the currently active chunk
+  char* chunk_end_;
+
+  // Scratch location in case we want a write to go nowhere.
+  // Does not point anywhere, just bitbuckets writes
+  char* scratch_;
+
+  std::vector<Chunk*> chunks_;
+};
+
+template<typename T>
+void Arena<T>::AddChunk() {
+  Chunk* chunk = new Chunk();
+  chunks_.push_back(chunk);
+  next_alloc_ = chunk->buf;
+  chunk_end_ = next_alloc_ + Chunk::kSize;
+  last_link_ = &scratch_;
+}
+
+template<typename T>
+void Arena<T>::DestroyObjects() {
+  for (int i = 0; i < static_cast<int>(chunks_.size()); ++i) {
+    // Walk through objects in this chunk.
+    char* base = chunks_[i]->buf;
+    while (base != NULL) {
+      reinterpret_cast<T*>(base + kAlign)->~T();
+      base = *reinterpret_cast<char**>(base);
+    }
+    delete chunks_[i];
+  }
+  chunks_.clear();
+  InitEmpty();
+}
+
+template<typename T>
+void Arena<T>::InitEmpty() {
+  // The way this is initialized ensures that the next call to allocate
+  // will call AddChunk(). Doing it this way rather than calling NewChunk()
+  // from here establishes the invariant that all the chunks are non-empty,
+  // which helps in DestroyObjects()
+  next_alloc_ = NULL;
+  last_link_ = NULL;
+  chunk_end_ = NULL;
+}
+
+}  // namespace  net_instaweb
+
+#endif  // NET_INSTAWEB_UTIL_PUBLIC_ARENA_H_

Propchange: httpd/mod_spdy/trunk/net/instaweb/util/public/arena.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: httpd/mod_spdy/trunk/net/instaweb/util/public/atom.h
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/public/atom.h?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/public/atom.h (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/public/atom.h Thu May  1 11:43:36 2014
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: jmarantz@google.com (Joshua Marantz)
+
+#ifndef NET_INSTAWEB_UTIL_PUBLIC_ATOM_H_
+#define NET_INSTAWEB_UTIL_PUBLIC_ATOM_H_
+
+#include <set>
+#include "net/instaweb/util/public/string.h"
+
+namespace net_instaweb {
+
+struct CaseFold;
+struct CasePreserve;
+template<class CharTransform> class SymbolTable;
+
+// Atoms are idempotent representations of strings, created
+// via a symbol table.
+class Atom {
+ public:
+  Atom(const Atom& src) : str_(src.str_) {}
+  Atom();
+  ~Atom() {}  // atoms are memory-managed by SymbolTables.
+
+  Atom& operator=(const Atom& src) {
+    if (&src != this) {
+      str_ = src.str_;
+    }
+    return *this;
+  }
+
+  // string-like accessors.
+  const char* c_str() const { return str_; }
+  int size() const { return strlen(str_); }
+
+  // This is comparing the underlying char* pointers.  It is invalid
+  // to compare Atoms from different symbol tables.
+  bool operator==(const Atom& sym) const {
+    return str_ == sym.str_;
+  }
+
+  // This is comparing the underlying char* pointers.  It is invalid
+  // to compare Atoms from different symbol tables.
+  bool operator!=(const Atom& sym) const {
+    return str_ != sym.str_;
+  }
+
+  // SymbolTable is a friend of Symbol because SymbolTable is the
+  // only class that has the right to construct a new Atom from
+  // a char*.
+  friend class SymbolTable<CaseFold>;
+  friend class SymbolTable<CasePreserve>;
+
+ private:
+  explicit Atom(const char* str) : str_(str) {}
+  const char* str_;
+};
+
+// Once interned, Atoms are very cheap to put in a set, using
+// pointer-comparison.
+struct AtomCompare {
+  bool operator()(const Atom& a1, const Atom& a2) const {
+    return a1.c_str() < a2.c_str();   // compares pointers
+  }
+};
+
+// A set of atoms can be constructed very efficiently.  Note that
+// iteration over this set will *not* be in alphabetical order.
+typedef std::set<Atom, AtomCompare> AtomSet;
+
+}  // namespace net_instaweb
+
+#endif  // NET_INSTAWEB_UTIL_PUBLIC_ATOM_H_

Propchange: httpd/mod_spdy/trunk/net/instaweb/util/public/atom.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: httpd/mod_spdy/trunk/net/instaweb/util/public/atomic_bool.h
URL: http://svn.apache.org/viewvc/httpd/mod_spdy/trunk/net/instaweb/util/public/atomic_bool.h?rev=1591622&view=auto
==============================================================================
--- httpd/mod_spdy/trunk/net/instaweb/util/public/atomic_bool.h (added)
+++ httpd/mod_spdy/trunk/net/instaweb/util/public/atomic_bool.h Thu May  1 11:43:36 2014
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Author: morlovich@google.com (Maksim Orlovich)
+
+#ifndef NET_INSTAWEB_UTIL_PUBLIC_ATOMIC_BOOL_H_
+#define NET_INSTAWEB_UTIL_PUBLIC_ATOMIC_BOOL_H_
+
+#include "net/instaweb/util/public/atomicops.h"
+#include "net/instaweb/util/public/basictypes.h"
+
+namespace net_instaweb {
+
+// A boolean flag that can be set atomically and be visible to other
+// threads. Please be extra careful with this --- it can go wrong in
+// incomprehensible  ways; most of the time, you probably want to use a mutex
+// instead.
+class AtomicBool {
+ public:
+  // Guaranteed to be initialized to false.
+  AtomicBool() {
+    set_value(false);
+  }
+
+  ~AtomicBool() {}
+
+  bool value() const {
+    return base::subtle::Acquire_Load(&value_);
+  }
+
+  void set_value(bool v) {
+    base::subtle::Release_Store(&value_, v);
+  }
+
+ private:
+  base::subtle::AtomicWord value_;
+  DISALLOW_COPY_AND_ASSIGN(AtomicBool);
+};
+
+
+}  // namespace net_instaweb
+
+#endif  // NET_INSTAWEB_UTIL_PUBLIC_ATOMIC_BOOL_H_

Propchange: httpd/mod_spdy/trunk/net/instaweb/util/public/atomic_bool.h
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message