Remember user decisions on invalid certificates behind a flag

chrome/browser/ssl/chrome_ssl_host_state_decisions_factory.h

+// Copyright (c) 2014 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.
+
+#ifndef CHROME_BROWSER_SSL_CHROME_SSL_HOST_STATE_DECISIONS_FACTORY_H_
+#define CHROME_BROWSER_SSL_CHROME_SSL_HOST_STATE_DECISIONS_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "base/prefs/pref_service.h"
+#include "base/values.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+class ChromeSSLHostStateDecisions;
+class Profile;
+
+// Singleton that associates all ChromeSSLHostStateDecisions with Profiles.
+class ChromeSSLHostStateDecisionsFactory
+    : public BrowserContextKeyedServiceFactory {
+ public:
+  static ChromeSSLHostStateDecisions* GetForProfile(Profile* profile);
+
+  static ChromeSSLHostStateDecisionsFactory* GetInstance();
+
+ private:
+  friend struct DefaultSingletonTraits<ChromeSSLHostStateDecisionsFactory>;
+
+  ChromeSSLHostStateDecisionsFactory();
+  virtual ~ChromeSSLHostStateDecisionsFactory();
+
+  // BrowserContextKeyedBaseFactor methods:

[Ryan Sleevi, 2014/07/31 00:31:28]

1) Factor -> Factory?
2) These should all be protected, not private, right? What does it even mean to
override private virtuals? In general, prefer to keep the same-or-greater
visibility as the parent; reducing visibility in a derived class is like using
the bathroom in a glass house - it gives the semblance of privacy, even though
you're still exposed.

[jww, 2014/07/31 05:57:00]

Done.
I agree that it's weird, but I'm going to push back only because all the
examples that I looked at and used as outlines for this class *do* make these
methods private (see
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/aut...
or
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/sup...
for example, although I believe just about every other class that subclasses
BrowserContextKeyedServiceFactory does this, from what I can tell).

[willchan no longer on Chromium, 2014/07/31 14:41:55]

In answer to your question about reducing visibility from the base class, I
present this chromium-dev thread:
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/CwzjcWd9cYM.
No comment on my personal opinion here.

In answer to your question about overriding private virtuals (but not about
reducing the visibility from the parent), I present Herb Sutter:

http://www.gotw.ca/publications/mill18.htm - "Guideline #2: Prefer to make
virtual functions private." and "Guideline #3: Only if derived classes need to
invoke the base implementation of a virtual function, make the virtual function
protected."

Overriding a private virtual function allows derived classes to override
specific hooks provided by base classes. But keeping it private means that only
the base class can control when this gets called.

class ThingThatFlies {
 public:
  void Fly() {
    PutOnAviatorSunglasses();
    FlyImpl();  // implemented by the derived class
    TakeOffAviatorSunglasses();
    PourSomeScotch();
  }

 private:
  // Derived classes can't call this impl. That's a good thing because
implementation inheritance is stupid.
  virtual void FlyImpl() { BoardAPlane(); }
};

class Bird : public ThingThatFlies {
 private:
  virtual void FlyImpl { FlapYoWingsLikeItsYoBirthday(); }
};

class Panda : public ThingThatFlies {
 private:
  virtual void FlyImpl { NOTREACHED() << "Pandas don't fly you insensitive
clod."; }
};

+  virtual KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* profile) const OVERRIDE;
+  virtual void RegisterProfilePrefs(
+      user_prefs::PrefRegistrySyncable* registry) OVERRIDE;
+  virtual content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeSSLHostStateDecisionsFactory);
+};
+
+#endif  // CHROME_BROWSER_SSL_CHROME_SSL_HOST_STATE_DECISIONS_FACTORY_H_