Modify ProtocolHandlerRegistry to make room for policy

chrome/browser/custom_handlers/protocol_handler_registry.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/custom_handlers/protocol_handler_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 318 matching lines @@
 
   if (AttemptReplace(handler))
     return true;
 
   return false;
 }
 
 void ProtocolHandlerRegistry::OnAcceptRegisterProtocolHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  RegisterProtocolHandler(handler);
+  RegisterProtocolHandler(handler, false);
   SetDefault(handler);
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::OnDenyRegisterProtocolHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  RegisterProtocolHandler(handler);
+  RegisterProtocolHandler(handler, false);
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::OnIgnoreRegisterProtocolHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  IgnoreProtocolHandler(handler);
+  IgnoreProtocolHandler(handler, false);
   Save();
   NotifyChanged();
 }
 
 bool ProtocolHandlerRegistry::AttemptReplace(const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandler old_default = GetHandlerFor(handler.protocol());
   bool make_new_handler_default = handler.IsSameOrigin(old_default);
   ProtocolHandlerList to_replace(GetReplacedHandlers(handler));
   if (to_replace.empty())
@@ skipping 69 matching lines @@
   is_loading_ = true;
 
   PrefService* prefs = profile_->GetPrefs();
   if (prefs->HasPrefPath(prefs::kCustomHandlersEnabled)) {
     if (prefs->GetBoolean(prefs::kCustomHandlersEnabled)) {
       Enable();
     } else {
       Disable();
     }
   }
   std::vector<const base::DictionaryValue*> registered_handlers =

[koz (OOO until 15th September), 2014/05/22 00:51:31]

It might be worth introducing some helper functions here, e.g.

RegisterHandlersFromPref(prefs::kPolicyRegisteredProtocolHandlers, true);
IgnoreHandlersFromPref(prefs::kPolicyIgnoredProtocolHandlers, true);

RegisterHandlersFromPref(prefs::kRegisteredProtocolHandlers, false);
IgnoreHandlersFromPref(prefs::kIgnoredProtocolHandlers, false);

[kaliamoorthi, 2014/05/30 10:01:09]

Done.

-      GetHandlersFromPref(prefs::kRegisteredProtocolHandlers);
+      GetHandlersFromPref(prefs::kPolicyRegisteredProtocolHandlers);
   for (std::vector<const base::DictionaryValue*>::const_iterator p =
        registered_handlers.begin();
        p != registered_handlers.end(); ++p) {
     ProtocolHandler handler = ProtocolHandler::CreateProtocolHandler(*p);
-    RegisterProtocolHandler(handler);
+    RegisterProtocolHandler(handler, true);
     bool is_default = false;
     if ((*p)->GetBoolean("default", &is_default) && is_default) {
       SetDefault(handler);
     }
   }
   std::vector<const base::DictionaryValue*> ignored_handlers =
-    GetHandlersFromPref(prefs::kIgnoredProtocolHandlers);
+      GetHandlersFromPref(prefs::kPolicyIgnoredProtocolHandlers);
   for (std::vector<const base::DictionaryValue*>::const_iterator p =
        ignored_handlers.begin();
        p != ignored_handlers.end(); ++p) {
-    IgnoreProtocolHandler(ProtocolHandler::CreateProtocolHandler(*p));
+    IgnoreProtocolHandler(ProtocolHandler::CreateProtocolHandler(*p), true);
+  }
+
+  registered_handlers = GetHandlersFromPref(prefs::kRegisteredProtocolHandlers);
+  for (std::vector<const base::DictionaryValue*>::const_iterator p =
+           registered_handlers.begin();
+       p != registered_handlers.end();
+       ++p) {
+    ProtocolHandler handler = ProtocolHandler::CreateProtocolHandler(*p);
+    RegisterProtocolHandler(handler, false);
+    bool is_default = false;
+    if ((*p)->GetBoolean("default", &is_default) && is_default) {
+      SetDefault(handler);
+    }
+  }
+  ignored_handlers = GetHandlersFromPref(prefs::kIgnoredProtocolHandlers);
+  for (std::vector<const base::DictionaryValue*>::const_iterator p =
+           ignored_handlers.begin();
+       p != ignored_handlers.end();
+       ++p) {
+    IgnoreProtocolHandler(ProtocolHandler::CreateProtocolHandler(*p), false);
   }
   is_loading_ = false;
 
   // For each default protocol handler, check that we are still registered
   // with the OS as the default application.
   if (ShouldRemoveHandlersNotInOS()) {
     for (ProtocolHandlerMap::const_iterator p = default_handlers_.begin();
          p != default_handlers_.end(); ++p) {
       ProtocolHandler handler = p->second;
       DefaultClientObserver* observer = delegate_->CreateShellObserver(this);
@@ skipping 110 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 void ProtocolHandlerRegistry::RemoveIgnoredHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool should_notify = false;
-  ProtocolHandlerList::iterator p = std::find(
-      ignored_protocol_handlers_.begin(), ignored_protocol_handlers_.end(),
-      handler);
-  if (p != ignored_protocol_handlers_.end()) {
-    ignored_protocol_handlers_.erase(p);
-    Save();
-    should_notify = true;
+  if (HandlerExists(handler, ignored_protocol_handlers_)) {
+    if (HandlerExists(handler, user_ignored_protocol_handlers_)) {
+      EraseHandler(handler, &user_ignored_protocol_handlers_);
+      Save();

[koz (OOO until 15th September), 2014/05/22 00:51:31]

Save() should be called after removing handler from ignored_protocol_handlers_
below.

[kaliamoorthi, 2014/05/30 10:01:09]

Please note that only user_ignored_protocol_handlers are saved.
ignored_protocol_handlers which is the in memory merged representation is not
saved, since it includes handlers from policy.

[koz (OOO until 15th September), 2014/06/01 23:44:28]

Ah, my bad. In that case feel free to revert to how you had the code before.

+      if (!HandlerExists(handler, policy_ignored_protocol_handlers_)) {
+        EraseHandler(handler, &ignored_protocol_handlers_);
+        should_notify = true;
+      }
+    }
   }
   if (should_notify)
     NotifyChanged();
 }
 
 bool ProtocolHandlerRegistry::IsHandledProtocol(
     const std::string& scheme) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return enabled_ && !GetHandlerFor(scheme).IsEmpty();
 }
 
 void ProtocolHandlerRegistry::RemoveHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandlerList& handlers = protocol_handlers_[handler.protocol()];
-  ProtocolHandlerList::iterator p =
-      std::find(handlers.begin(), handlers.end(), handler);
-  if (p != handlers.end()) {
-    handlers.erase(p);
+  bool erase_success = false;
+  if (HandlerExists(handler, handlers)) {
+    if (HandlerExists(handler, &user_protocol_handlers_)) {
+      EraseHandler(handler, &user_protocol_handlers_);
+      if (!HandlerExists(handler, &policy_protocol_handlers_)) {
+        erase_success = true;
+        EraseHandler(handler, &protocol_handlers_);
+      }
+    }
   }
   ProtocolHandlerMap::iterator q = default_handlers_.find(handler.protocol());
-  if (q != default_handlers_.end() && q->second == handler) {
+  if (erase_success && q != default_handlers_.end() && q->second == handler) {
     // Make the new top handler in the list the default.
     if (!handlers.empty()) {
       // NOTE We pass a copy because SetDefault() modifies handlers.
       SetDefault(ProtocolHandler(handlers[0]));
     } else {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_,
                      q->second.protocol()));
 
       default_handlers_.erase(q);
     }
   }
 
-  if (!IsHandledProtocol(handler.protocol())) {
+  if (erase_success && !IsHandledProtocol(handler.protocol())) {
     delegate_->DeregisterExternalHandler(handler.protocol());
   }
   Save();
-  NotifyChanged();
+  if (erase_success)
+    NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::RemoveDefaultHandler(const std::string& scheme) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandler current_default = GetHandlerFor(scheme);
   if (!current_default.IsEmpty())
     RemoveHandler(current_default);
 }
 
 const ProtocolHandler& ProtocolHandlerRegistry::GetHandlerFor(
@@ skipping 136 matching lines @@
   }
 
   ProtocolHandlerList new_list;
   new_list.push_back(handler);
   protocol_handlers_[handler.protocol()] = new_list;
 }
 
 base::Value* ProtocolHandlerRegistry::EncodeRegisteredHandlers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::ListValue* protocol_handlers = new base::ListValue();
-  for (ProtocolHandlerMultiMap::iterator i = protocol_handlers_.begin();
-       i != protocol_handlers_.end(); ++i) {
+  for (ProtocolHandlerMultiMap::iterator i = user_protocol_handlers_.begin();
+       i != user_protocol_handlers_.end();
+       ++i) {
     for (ProtocolHandlerList::iterator j = i->second.begin();
          j != i->second.end(); ++j) {
       base::DictionaryValue* encoded = j->Encode();
       if (IsDefault(*j)) {
         encoded->Set("default", base::Value::CreateBooleanValue(true));
       }
       protocol_handlers->Append(encoded);
     }
   }
   return protocol_handlers;
 }
 
 base::Value* ProtocolHandlerRegistry::EncodeIgnoredHandlers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::ListValue* handlers = new base::ListValue();
-  for (ProtocolHandlerList::iterator i = ignored_protocol_handlers_.begin();
-       i != ignored_protocol_handlers_.end(); ++i) {
+  for (ProtocolHandlerList::iterator i =
+           user_ignored_protocol_handlers_.begin();
+       i != user_ignored_protocol_handlers_.end();
+       ++i) {
     handlers->Append(i->Encode());
   }
   return handlers;
 }
 
 void ProtocolHandlerRegistry::NotifyChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
 void ProtocolHandlerRegistry::RegisterProtocolHandler(
-    const ProtocolHandler& handler) {
+    const ProtocolHandler& handler,
+    const bool policy_managed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(CanSchemeBeOverridden(handler.protocol()));
   DCHECK(!handler.IsEmpty());
+  ProtocolHandlerMultiMap& map =
+      policy_managed ? policy_protocol_handlers_ : user_protocol_handlers_;
+  ProtocolHandlerList& list = map[handler.protocol()];
+  if (!HandlerExists(handler, list))
+    list.push_back(handler);
   if (IsRegistered(handler)) {
     return;
   }
   if (enabled_ && !delegate_->IsExternalHandlerRegistered(handler.protocol()))
     delegate_->RegisterExternalHandler(handler.protocol());
   InsertHandler(handler);
 }
 
 std::vector<const base::DictionaryValue*>
 ProtocolHandlerRegistry::GetHandlersFromPref(const char* pref_name) const {
@@ skipping 12 matching lines @@
         continue;
       if (ProtocolHandler::IsValidDict(dict)) {
         result.push_back(dict);
       }
     }
   }
   return result;
 }
 
 void ProtocolHandlerRegistry::IgnoreProtocolHandler(
-    const ProtocolHandler& handler) {
+    const ProtocolHandler& handler,
+    const bool policy_managed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ignored_protocol_handlers_.push_back(handler);
+  ProtocolHandlerList& list = policy_managed ? policy_ignored_protocol_handlers_
+                                             : user_ignored_protocol_handlers_;
+  if (!HandlerExists(handler, list))
+    list.push_back(handler);
+}
+
+bool ProtocolHandlerRegistry::HandlerExists(const ProtocolHandler& handler,
+                                            ProtocolHandlerMultiMap* map) {
+  return HandlerExists(handler, (*map)[handler.protocol()]);
+}
+
+bool ProtocolHandlerRegistry::HandlerExists(const ProtocolHandler& handler,
+                                            const ProtocolHandlerList& list) {
+  return (std::find(list.begin(), list.end(), handler) != list.end());

[koz (OOO until 15th September), 2014/05/22 00:51:31]

nit: no need for parens

[kaliamoorthi, 2014/05/30 10:01:09]

Done.

+}
+
+void ProtocolHandlerRegistry::EraseHandler(const ProtocolHandler& handler,
+                                           ProtocolHandlerMultiMap* map) {
+  EraseHandler(handler, &(*map)[handler.protocol()]);
+}
+
+void ProtocolHandlerRegistry::EraseHandler(const ProtocolHandler& handler,
+                                           ProtocolHandlerList* list) {
+  ProtocolHandlerList::iterator p =
+      std::find(list->begin(), list->end(), handler);
+  list->erase(p);
 }
 
 void ProtocolHandlerRegistry::AddPredefinedHandler(
     const ProtocolHandler& handler) {
   DCHECK(!is_loaded_);  // Must be called prior InitProtocolSettings.
-  RegisterProtocolHandler(handler);
+  RegisterProtocolHandler(handler, false);
   SetDefault(handler);
 }
 
 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // this is always created on the UI thread (in profile_io's
   // InitializeOnUIThread. Any method calls must be done
   // on the IO thread (this is checked).
   return scoped_ptr<JobInterceptorFactory>(
       new JobInterceptorFactory(io_thread_delegate_.get()));
 }