[Garbled Text][Infobar] Adding infobar to suggest turning on encoding detection.

chrome/browser/garbled_text_service.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 "chrome/browser/garbled_text_service.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "chrome/browser/garbled_text_url_tracker.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_dependency_manager.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_source.h"
+
+const char GarbledTextService::kPrefGarbledTextBlacklist[] =
+    "garbled_text_sites";
+
+// When the blacklist grows over |kBlacklistSizeLimit|, we reduce it to
+// kBlacklistReduceRatio * kBlacklistSizeLimit in manner of least recent added.
+const size_t kBlacklistSizeLimit = 2000;
+const size_t kBlacklistReduceRatio = 0.5;
+
+namespace {
+
+void SetPrefBlacklist(PrefService* user_prefs,
+                      const GarbledTextService::Blacklist& blacklist) {
+  ListPrefUpdate update(user_prefs,
+                        GarbledTextService::kPrefGarbledTextBlacklist);
+  ListValue* pref_blacklist = update.Get();
+  if (!pref_blacklist) {
+    NOTREACHED();
+    return;
+  }
+  pref_blacklist->Clear();
+
+  for (GarbledTextService::Blacklist::const_iterator itr = blacklist.begin();
+       itr != blacklist.end(); ++itr)
+    pref_blacklist->Append(base::Value::CreateStringValue(*itr));
+}
+
+}  // anonymous namespace
+
+GarbledTextServiceParams::GarbledTextServiceParams(PrefService* user_prefs,
+                                                   GarbledTextService* service)
+    : service_(service->AsWeakPtr()) {
+  DCHECK(user_prefs);
+  DCHECK(service);
+
+  const ListValue* pref_blacklist = user_prefs->GetList(
+      GarbledTextService::kPrefGarbledTextBlacklist);
+  if (pref_blacklist) {
+    size_t i = 0;
+    if (pref_blacklist->GetSize() > kBlacklistSizeLimit) {
+      size_t new_size = kBlacklistSizeLimit * kBlacklistReduceRatio;
+      i = pref_blacklist->GetSize() - new_size;
+    }
+
+    for (; i < pref_blacklist->GetSize(); ++i) {
+      std::string value;
+      if (pref_blacklist->GetString(i, &value))
+        blacklist_.insert(value);
+    }
+
+    if (pref_blacklist->GetSize() > kBlacklistSizeLimit)
+      SetPrefBlacklist(user_prefs, blacklist_);
+  }
+}
+
+GarbledTextServiceParams::~GarbledTextServiceParams() {
+}
+
+scoped_ptr<GarbledTextURLTracker> GarbledTextServiceParams::CreateTracker(
+    const BooleanPrefMember& enabled) {
+  scoped_ptr<GarbledTextURLTracker> tracker(
+      new GarbledTextURLTracker(enabled, blacklist_));
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&GarbledTextService::SetTracker,
+                 service_, tracker->AsWeakPtr()));
+  return tracker.Pass();
+}
+
+// static
+GarbledTextService* GarbledTextServiceFactory::GetForProfile(
+    Profile* profile) {
+  return static_cast<GarbledTextService*>(
+      GetInstance()->GetServiceForProfile(profile, true));
+}
+
+// static
+GarbledTextServiceFactory* GarbledTextServiceFactory::GetInstance() {
+  return Singleton<GarbledTextServiceFactory>::get();
+}
+
+GarbledTextServiceFactory::GarbledTextServiceFactory()
+    : ProfileKeyedServiceFactory(ProfileDependencyManager::GetInstance()) {
+}
+
+GarbledTextServiceFactory::~GarbledTextServiceFactory() {}
+
+ProfileKeyedService* GarbledTextServiceFactory::BuildServiceInstanceFor(
+    Profile* profile) const {
+  return new GarbledTextService(profile);
+}
+
+void GarbledTextServiceFactory::RegisterUserPrefs(PrefService* user_prefs) {
+  if (!user_prefs->FindPreference(prefs::kEnableAutoGarbledTextFix)) {
+    user_prefs->RegisterBooleanPref(prefs::kEnableAutoGarbledTextFix,
+                                    true,
+                                    PrefService::UNSYNCABLE_PREF);
+  }
+
+  if (!user_prefs->FindPreference(
+          GarbledTextService::kPrefGarbledTextBlacklist)) {
+    user_prefs->RegisterListPref(
+        GarbledTextService::kPrefGarbledTextBlacklist,
+        PrefService::UNSYNCABLE_PREF);
+  }
+}
+
+bool GarbledTextServiceFactory::ServiceHasOwnInstanceInIncognito() {
+  return true;
+}
+
+bool GarbledTextServiceFactory::ServiceIsNULLWhileTesting() {
+  return false;
+}
+
+GarbledTextService::GarbledTextService(Profile* profile)
+    : profile_(profile) {
+  DCHECK(profile_);
+}
+
+GarbledTextService::~GarbledTextService() {
+  DCHECK(CalledOnValidThread());
+}
+
+void GarbledTextService::SetTracker(
+    base::WeakPtr<GarbledTextURLTracker> tracker) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!tracker_.get());
+  tracker_ = tracker;
+}
+
+void GarbledTextService::UpdateBlacklist(const GarbledURLs& garbled_urls,
+                                         const base::Closure& callback) {
+  DCHECK(CalledOnValidThread());
+
+  scoped_ptr<Blacklist> blacklist_delta(new Blacklist);
+  base::Closure post(
+      base::Bind(&GarbledTextURLTracker::UpdateBlacklist,
+                 tracker_, garbled_urls, blacklist_delta.get()));
+  base::Closure reply(
+      base::Bind(&GarbledTextService::UpdatePref, AsWeakPtr(),
+                 base::Owned(blacklist_delta.release()), callback));
+  content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::IO, FROM_HERE, post, reply);
+}
+
+void GarbledTextService::UpdatePref(const Blacklist* blacklist_delta,
+                                    const base::Closure& callback) {
+  DCHECK(CalledOnValidThread());
+
+  PrefService* user_prefs = profile_->GetPrefs();
+  DCHECK(user_prefs);
+
+  ListPrefUpdate update(user_prefs, kPrefGarbledTextBlacklist);
+  ListValue* blacklist = update.Get();
+  if (!blacklist) {
+    NOTREACHED();
+    return;
+  }
+  for (Blacklist::const_iterator itr = blacklist_delta->begin();
+       itr != blacklist_delta->end(); ++itr)
+    blacklist->Append(base::Value::CreateStringValue(*itr));
+
+  callback.Run();
+}