Privacy Blacklist Unblock...

chrome/browser/privacy_blacklist/blocked_response.cc

 // Copyright (c) 2009 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 "chrome/browser/privacy_blacklist/blocked_response.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/logging.h"
+#include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/common/jstemplate_builder.h"
+#include "chrome/common/url_constants.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 
-namespace BlockedResponse {
+namespace {
 
-std::string GetHTML(const Blacklist::Match* match) {
+unsigned long Hash(std::set<std::string>::iterator i) {
+  return (unsigned long)(i.operator->());
+}
+
+std::string Dehash(unsigned long l) {
+  return *(std::string*)l;
+}
+
+}
+
+namespace chrome {
+
+const char kUnblockScheme[] = "chrome-unblock";
+
+const char kBlockScheme[] = "chrome-block";
+
+std::string BlockedResponse::GetHTML(const std::string& url,
+                                     const Blacklist::Match* match) {
   DictionaryValue strings;
   strings.SetString(L"title", l10n_util::GetString(IDS_BLACKLIST_TITLE));
   strings.SetString(L"message", l10n_util::GetString(IDS_BLACKLIST_MESSAGE));
   strings.SetString(L"unblock", l10n_util::GetString(IDS_BLACKLIST_UNBLOCK));
 
   // If kBlockAll is specified, assign blame to such an entry.
   // Otherwise pick the first one.
   const Blacklist::Entry* entry = NULL;
   if (match->attributes() & Blacklist::kBlockAll) {
     for (std::vector<const Blacklist::Entry*>::const_iterator i =
          match->entries().begin(); i != match->entries().end(); ++i) {
       if ((*i)->attributes() == Blacklist::kBlockAll) {
         entry = *i;
         break;
       }
     }
   } else {
     entry = match->entries().front();
   }
   DCHECK(entry);
 
   strings.SetString(L"name", entry->provider()->name());
   strings.SetString(L"url", entry->provider()->url());
+  strings.SetString(L"bypass", GetUnblockedURL(url));
 
   const base::StringPiece html =
     ResourceBundle::GetSharedInstance().GetRawDataResource(IDR_BLACKLIST_HTML);
   return jstemplate_builder::GetI18nTemplateHtml(html, &strings);
 }
 
-std::string GetImage(const Blacklist::Match*) {
+std::string BlockedResponse::GetImage(const Blacklist::Match*) {
   return ResourceBundle::GetSharedInstance().
       GetDataResource(IDR_BLACKLIST_IMAGE);
 }
 
-}  // namespace BlockedResponse
+std::string BlockedResponse::GetHeaders(const std::string& url) {
+  return
+      "HTTP/1.1 200 OK\nContent-Type: text/html\nlocation: "
+      + GetBlockedURL(url) + "\n" + "Cache-Control: no-store";
+}
+
+std::string BlockedResponse::GetBlockedURL(const std::string& url) {
+  return std::string(kBlockScheme) + "://" + url;
+}
+
+std::string BlockedResponse::GetUnblockedURL(const std::string& url) {
+  std::set<std::string>::iterator i = blocked_.insert(blocked_.end(), url);
+
+  char buf[64];
+  base::snprintf(buf, 64, "%s://%lX", kUnblockScheme, Hash(i));
+  return  buf;
+}
+
+std::string BlockedResponse::GetOriginalURL(const std::string& url) {
+  unsigned long l = 0;
+
+  // Read the address of the url.
+  if (sscanf(url.c_str() + sizeof(kUnblockScheme) + 2, "%lX", &l)) {
+    std::size_t p = url.find('/', sizeof(kUnblockScheme) + 2);
+    if (p != std::string::npos)
+      return Dehash(l) + url.substr(p+1);
+    return Dehash(l);
+  }
+  return chrome::kAboutBlankURL;
+}
+
+}  // end namespace chrome