net/instaweb/http/counting_url_async_fetcher.cc

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */


#include "net/instaweb/http/public/counting_url_async_fetcher.h"

#include "net/instaweb/http/public/async_fetch.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

class MessageHandler;

class CountingUrlAsyncFetcher::CountingFetch : public SharedAsyncFetch {
 public:
  CountingFetch(CountingUrlAsyncFetcher* counter, AsyncFetch* base_fetch)
      : SharedAsyncFetch(base_fetch), counter_(counter) {
    ScopedMutex lock(counter_->mutex_.get());
    ++counter_->fetch_start_count_;
  }

  virtual bool HandleWrite(const StringPiece& content,
                           MessageHandler* handler) {
    {
      ScopedMutex lock(counter_->mutex_.get());
      counter_->byte_count_ += content.size();
    }
    return SharedAsyncFetch::HandleWrite(content, handler);
  }

  virtual void HandleDone(bool success) {
    {
      ScopedMutex lock(counter_->mutex_.get());
      ++counter_->fetch_count_;
      if (!success) {
        ++counter_->failure_count_;
      }
    }
    SharedAsyncFetch::HandleDone(success);
    delete this;
  }

 private:
  CountingUrlAsyncFetcher* counter_;

  DISALLOW_COPY_AND_ASSIGN(CountingFetch);
};

CountingUrlAsyncFetcher::~CountingUrlAsyncFetcher() {
}

void CountingUrlAsyncFetcher::Fetch(const GoogleString& url,
                                    MessageHandler* message_handler,
                                    AsyncFetch* base_fetch) {
  {
    ScopedMutex lock(mutex_.get());
    most_recent_fetched_url_ = url;
  }
  CountingFetch* counting_fetch = new CountingFetch(this, base_fetch);
  fetcher_->Fetch(url, message_handler, counting_fetch);
}

void CountingUrlAsyncFetcher::Clear() {
  ScopedMutex lock(mutex_.get());
  fetch_count_ = 0;
  fetch_start_count_ = 0;
  byte_count_ = 0;
  failure_count_ = 0;
  most_recent_fetched_url_ = "";
}

}  // namespace net_instaweb