Third-party appcache blocking.

webkit/appcache/appcache_update_job.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/appcache/appcache_update_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/appcache/appcache_group.h"
-#include "webkit/appcache/appcache_policy.h"
 
 namespace appcache {
 
 static const int kBufferSize = 32768;
 static const size_t kMaxConcurrentUrlFetches = 2;
 static const int kMax503Retries = 3;
 
 // Helper class for collecting hosts per frontend when sending notifications
 // so that only one notification is sent for all hosts using the same frontend.
 class HostNotifier {
@@ skipping 265 matching lines @@
       internal_state_(FETCH_MANIFEST),
       master_entries_completed_(0),
       url_fetches_completed_(0),
       manifest_fetcher_(NULL),
       stored_state_(UNSTORED),
       ALLOW_THIS_IN_INITIALIZER_LIST(manifest_info_write_callback_(
           this, &AppCacheUpdateJob::OnManifestInfoWriteComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(manifest_data_write_callback_(
           this, &AppCacheUpdateJob::OnManifestDataWriteComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(manifest_data_read_callback_(
-          this, &AppCacheUpdateJob::OnManifestDataReadComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(policy_callback_(
-          new net::CancelableCompletionCallback<AppCacheUpdateJob>(
-              this, &AppCacheUpdateJob::OnPolicyCheckComplete))) {
+          this, &AppCacheUpdateJob::OnManifestDataReadComplete)) {
   DCHECK(group_);
   manifest_url_ = group_->manifest_url();
 }
 
 AppCacheUpdateJob::~AppCacheUpdateJob() {
   if (internal_state_ != COMPLETED)
     Cancel();
 
   DCHECK(!manifest_fetcher_);
   DCHECK(pending_url_fetches_.empty());
   DCHECK(!inprogress_cache_);
   DCHECK(pending_master_entries_.empty());
   DCHECK(master_entry_fetches_.empty());
 
   if (group_)
     group_->SetUpdateStatus(AppCacheGroup::IDLE);
-
-  policy_callback_->Cancel();
 }
 
 void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
                                     const GURL& new_master_resource) {
   DCHECK(group_->update_job() == this);
   DCHECK(!group_->is_obsolete());
 
   bool is_new_pending_master_entry = false;
   if (!new_master_resource.is_empty()) {
     DCHECK(new_master_resource == host->pending_master_entry_url());
@@ skipping 41 matching lines @@
     update_type_ = CACHE_ATTEMPT;
     DCHECK(host);
     NotifySingleHost(host, CHECKING_EVENT);
   }
 
   if (!new_master_resource.is_empty()) {
     AddMasterEntryToFetchList(host, new_master_resource,
                               is_new_pending_master_entry);
   }
 
-  if (update_type_ == CACHE_ATTEMPT)
-    CheckPolicy();
-  else
-    FetchManifest(true);
-}
-
-void AppCacheUpdateJob::CheckPolicy() {
-  int rv = net::OK;
-  policy_callback_->AddRef();  // Balanced in OnPolicyCheckComplete.
-  AppCachePolicy* policy = service_->appcache_policy();
-  if (policy) {
-    rv = policy->CanCreateAppCache(manifest_url_, policy_callback_);
-    if (rv == net::ERR_IO_PENDING)
-      return;
-  }
-  OnPolicyCheckComplete(rv);
-}
-
-void AppCacheUpdateJob::OnPolicyCheckComplete(int rv) {
-  policy_callback_->Release();  // Balanced in CheckPolicy.
-  if (rv == net::OK) {
-    FetchManifest(true);
-    return;
-  }
-
-  group_->NotifyContentBlocked();
-
-  const char* kErrorMessage =
-      "Cache creation was blocked by the content policy";
-  MessageLoop::current()->PostTask(FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &AppCacheUpdateJob::HandleCacheFailure,
-          kErrorMessage));
+  FetchManifest(true);
 }
 
 AppCacheResponseWriter* AppCacheUpdateJob::CreateResponseWriter() {
   AppCacheResponseWriter* writer =
       service_->storage()->CreateResponseWriter(manifest_url_);
   stored_response_ids_.push_back(writer->response_id());
   return writer;
 }
 
 void AppCacheUpdateJob::HandleCacheFailure(const std::string& error_message) {
@@ skipping 870 matching lines @@
   master_entry_fetches_.clear();
 
   ClearPendingMasterEntries();
   DiscardInprogressCache();
 
   // Delete response writer to avoid any callbacks.
   if (manifest_response_writer_.get())
     manifest_response_writer_.reset();
 
   service_->storage()->CancelDelegateCallbacks(this);
-
-  policy_callback_->Cancel();
 }
 
 void AppCacheUpdateJob::ClearPendingMasterEntries() {
   for (PendingMasters::iterator it = pending_master_entries_.begin();
        it != pending_master_entries_.end(); ++it) {
     PendingHosts& hosts = it->second;
     for (PendingHosts::iterator host_it = hosts.begin();
          host_it != hosts.end(); ++host_it) {
       (*host_it)->RemoveObserver(this);
     }
@@ skipping 33 matching lines @@
 
   // Break the connection with the group so the group cannot call delete
   // on this object after we've posted a task to delete ourselves.
   group_->SetUpdateStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache