Move all remaining appcache-related code to content namespace

content/browser/appcache/appcache_update_job.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/browser/appcache/appcache_update_job.h"
+#include "content/browser/appcache/appcache_update_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "content/browser/appcache/appcache_group.h"
+#include "content/browser/appcache/appcache_histograms.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
-#include "webkit/browser/appcache/appcache_group.h"
-#include "webkit/browser/appcache/appcache_histograms.h"
 
-namespace appcache {
+namespace content {
 
 static const int kBufferSize = 32768;
 static const size_t kMaxConcurrentUrlFetches = 2;
 static const int kMax503Retries = 3;
 
 static std::string FormatUrlErrorMessage(
       const char* format, const GURL& url,
       AppCacheUpdateJob::ResultType error,
       int response_code) {
     // Show the net response code if we have one.
@@ skipping 485 matching lines @@
   } else if (response_code == 304 && update_type_ == UPGRADE_ATTEMPT) {
     ContinueHandleManifestFetchCompleted(false);
   } else if ((response_code == 404 || response_code == 410) &&
              update_type_ == UPGRADE_ATTEMPT) {
     storage_->MakeGroupObsolete(group_, this, response_code);  // async
   } else {
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, manifest_url_, fetcher->result(), response_code);
     HandleCacheFailure(AppCacheErrorDetails(message,
-                                    appcache::APPCACHE_MANIFEST_ERROR,
+                                    APPCACHE_MANIFEST_ERROR,
                                     manifest_url_,
                                     response_code,
                                     false /*is_cross_origin*/),
                        fetcher->result(),
                        GURL());
   }
 }
 
 void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
                                             bool success,
                                             int response_code) {
   DCHECK(master_entry_fetches_.empty());
   CancelAllMasterEntryFetches(AppCacheErrorDetails(
       "The cache has been made obsolete, "
       "the manifest file returned 404 or 410",
-      appcache::APPCACHE_MANIFEST_ERROR,
+      APPCACHE_MANIFEST_ERROR,
       GURL(),
       response_code,
       false /*is_cross_origin*/));
   if (success) {
     DCHECK(group->is_obsolete());
     NotifyAllAssociatedHosts(APPCACHE_OBSOLETE_EVENT);
     internal_state_ = COMPLETED;
     MaybeCompleteUpdate();
   } else {
     // Treat failure to mark group obsolete as a cache failure.
@@ skipping 28 matching lines @@
                         PARSE_MANIFEST_ALLOWING_INTERCEPTS :
                         PARSE_MANIFEST_PER_STANDARD,
                      manifest)) {
     const char* kFormatString = "Failed to parse manifest %s";
     const std::string message = base::StringPrintf(kFormatString,
         manifest_url_.spec().c_str());
     HandleCacheFailure(
         AppCacheErrorDetails(
             message, APPCACHE_SIGNATURE_ERROR, GURL(), 0,
             false /*is_cross_origin*/),
-        APPCACHE_MANIFEST_ERROR,
+        MANIFEST_ERROR,
         GURL());
     VLOG(1) << message;
     return;
   }
 
   // Proceed with update process. Section 6.9.4 steps 8-20.
   internal_state_ = DOWNLOADING;
   inprogress_cache_ = new AppCache(storage_, storage_->NewCacheId());
   BuildUrlFileList(manifest);
   inprogress_cache_->InitializeWithManifest(&manifest);
@@ skipping 178 matching lines @@
 
       host->RemoveObserver(this);
     }
     hosts.clear();
 
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, request->url(), fetcher->result(), response_code);
     host_notifier.SendErrorNotifications(
         AppCacheErrorDetails(message,
-                     appcache::APPCACHE_MANIFEST_ERROR,
+                     APPCACHE_MANIFEST_ERROR,
                      request->url(),
                      response_code,
                      false /*is_cross_origin*/));
 
     // In downloading case, update result is different if all master entries
     // failed vs. only some failing.
     if (inprogress_cache_.get()) {
       // Only count successful downloads to know if all master entries failed.
       pending_master_entries_.erase(found);
       --master_entries_completed_;
 
       // Section 6.9.4, step 22.3.
       if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
         HandleCacheFailure(AppCacheErrorDetails(message,
-                                        appcache::APPCACHE_MANIFEST_ERROR,
+                                        APPCACHE_MANIFEST_ERROR,
                                         request->url(),
                                         response_code,
                                         false /*is_cross_origin*/),
                            fetcher->result(),
                            GURL());
         return;
       }
     }
   }
 
@@ skipping 31 matching lines @@
     VLOG(1) << "Request status: " << request->status().status()
             << " error: " << request->status().error()
             << " response code: " << response_code;
     ScheduleUpdateRetry(kRerunDelayMs);
     if (response_code == 200) {
       HandleCacheFailure(AppCacheErrorDetails("Manifest changed during update",
                                       APPCACHE_CHANGED_ERROR,
                                       GURL(),
                                       0,
                                       false /*is_cross_origin*/),
-                         APPCACHE_MANIFEST_ERROR,
+                         MANIFEST_ERROR,
                          GURL());
     } else {
       const char* kFormatString = "Manifest re-fetch failed (%d) %s";
       std::string message = FormatUrlErrorMessage(
           kFormatString, manifest_url_, fetcher->result(), response_code);
       HandleCacheFailure(AppCacheErrorDetails(message,
-                                      appcache::APPCACHE_MANIFEST_ERROR,
+                                      APPCACHE_MANIFEST_ERROR,
                                       GURL(),
                                       response_code,
                                       false /*is_cross_origin*/),
                          fetcher->result(),
                          GURL());
     }
   }
 }
 
 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
@@ skipping 66 matching lines @@
     // Restore inprogress_cache_ to get the proper events delivered
     // and the proper cleanup to occur.
     if (newest_cache != group->newest_complete_cache())
       inprogress_cache_ = newest_cache;
 
     ResultType result = DB_ERROR;
     AppCacheErrorReason reason = APPCACHE_UNKNOWN_ERROR;
     std::string message("Failed to commit new cache to storage");
     if (would_exceed_quota) {
       message.append(", would exceed quota");
-      result = APPCACHE_QUOTA_ERROR;
-      reason = appcache::APPCACHE_QUOTA_ERROR;
+      result = QUOTA_ERROR;
+      reason = APPCACHE_QUOTA_ERROR;
     }
     HandleCacheFailure(
         AppCacheErrorDetails(message, reason, GURL(), 0,
             false /*is_cross_origin*/),
         result,
         GURL());
   }
 }
 
 void AppCacheUpdateJob::NotifySingleHost(AppCacheHost* host,
@@ skipping 126 matching lines @@
   }
 }
 
 void AppCacheUpdateJob::BuildUrlFileList(const Manifest& manifest) {
   for (base::hash_set<std::string>::const_iterator it =
            manifest.explicit_urls.begin();
        it != manifest.explicit_urls.end(); ++it) {
     AddUrlToFileList(GURL(*it), AppCacheEntry::EXPLICIT);
   }
 
-  const std::vector<Namespace>& intercepts =
+  const std::vector<AppCacheNamespace>& intercepts =
       manifest.intercept_namespaces;
-  for (std::vector<Namespace>::const_iterator it = intercepts.begin();
+  for (std::vector<AppCacheNamespace>::const_iterator it = intercepts.begin();
        it != intercepts.end(); ++it) {
     int flags = AppCacheEntry::INTERCEPT;
     if (it->is_executable)
       flags |= AppCacheEntry::EXECUTABLE;
     AddUrlToFileList(it->target_url, flags);
   }
 
-  const std::vector<Namespace>& fallbacks =
+  const std::vector<AppCacheNamespace>& fallbacks =
       manifest.fallback_namespaces;
-  for (std::vector<Namespace>::const_iterator it = fallbacks.begin();
+  for (std::vector<AppCacheNamespace>::const_iterator it = fallbacks.begin();
        it != fallbacks.end(); ++it) {
      AddUrlToFileList(it->target_url, AppCacheEntry::FALLBACK);
   }
 
   // Add all master entries from newest complete cache.
   if (update_type_ == UPGRADE_ATTEMPT) {
     const AppCache::EntryMap& entries =
         group_->newest_complete_cache()->entries();
     for (AppCache::EntryMap::const_iterator it = entries.begin();
          it != entries.end(); ++it) {
@@ skipping 476 matching lines @@
   service_ = NULL;
 
   // 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_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-}  // namespace appcache
+}  // namespace content