Changes to content/ to facilitate new zoom extension API

content/browser/host_zoom_map_impl.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 "content/browser/host_zoom_map_impl.h"
 
 #include <cmath>
+#include <set>
 
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/resource_context.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/common/page_zoom.h"
 #include "net/base/net_util.h"
 
 static const char* kHostZoomMapKeyName = "content_host_zoom_map";
 
 namespace content {
 
 HostZoomMap* HostZoomMap::GetForBrowserContext(BrowserContext* context) {
   HostZoomMapImpl* rv = static_cast<HostZoomMapImpl*>(
       context->GetUserData(kHostZoomMapKeyName));
   if (!rv) {
     rv = new HostZoomMapImpl();
     context->SetUserData(kHostZoomMapKeyName, rv);
   }
   return rv;
 }
 
 HostZoomMapImpl::HostZoomMapImpl()
     : default_zoom_level_(0.0) {
   registrar_.Add(
       this, NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW,
       NotificationService::AllSources());
+  registrar_.Add(
+      this, NOTIFICATION_WEB_CONTENTS_NO_TEMPORARY_ZOOM_LEVEL,
+      NotificationService::AllSources());
 }
 
 void HostZoomMapImpl::CopyFrom(HostZoomMap* copy_interface) {
   // This can only be called on the UI thread to avoid deadlocks, otherwise
   //   UI: a.CopyFrom(b);
   //   IO: b.CopyFrom(a);
   // can deadlock.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   HostZoomMapImpl* copy = static_cast<HostZoomMapImpl*>(copy_interface);
   base::AutoLock auto_lock(lock_);
@@ skipping 63 matching lines @@
         };
         result.push_back(change);
       }
     }
   }
   return result;
 }
 
 void HostZoomMapImpl::SetZoomLevelForHost(const std::string& host,
                                           double level) {
+  SetZoomLevelForHost(host, 0, level);
+}
+
+void HostZoomMapImpl::SetZoomLevelForHost(const std::string& host,
+                                          int zoom_id,
+                                          double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
     base::AutoLock auto_lock(lock_);
 
     if (ZoomValuesEqual(level, default_zoom_level_))
       host_zoom_levels_.erase(host);
     else
       host_zoom_levels_[host] = level;
   }
 
-  // Notify renderers from this browser context.
-  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    RenderProcessHost* render_process_host = i.GetCurrentValue();
-    if (HostZoomMap::GetForBrowserContext(
-            render_process_host->GetBrowserContext()) == this) {
-      render_process_host->Send(
-          new ViewMsg_SetZoomLevelForCurrentURL(std::string(), host, level));
-    }
-  }
+  SendZoomLevelChange(std::string(), host, level);
+
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_FOR_HOST;
   change.host = host;
   change.zoom_level = level;
 
+  CallZoomCallback(zoom_id);
   zoom_level_changed_callbacks_.Notify(change);
 }
 
 void HostZoomMapImpl::SetZoomLevelForHostAndScheme(const std::string& scheme,
                                                    const std::string& host,
                                                    double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   {
     base::AutoLock auto_lock(lock_);
     scheme_host_zoom_levels_[scheme][host] = level;
   }
 
-  // Notify renderers from this browser context.
-  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    RenderProcessHost* render_process_host = i.GetCurrentValue();
-    if (HostZoomMap::GetForBrowserContext(
-            render_process_host->GetBrowserContext()) == this) {
-      render_process_host->Send(
-          new ViewMsg_SetZoomLevelForCurrentURL(scheme, host, level));
-    }
-  }
+  SendZoomLevelChange(scheme, host, level);
 
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST;
   change.host = host;
   change.scheme = scheme;
   change.zoom_level = level;
 
   zoom_level_changed_callbacks_.Notify(change);
 }
 
 double HostZoomMapImpl::GetDefaultZoomLevel() const {
   return default_zoom_level_;
 }
 
 void HostZoomMapImpl::SetDefaultZoomLevel(double level) {
   default_zoom_level_ = level;
 }
 
 scoped_ptr<HostZoomMap::Subscription>
 HostZoomMapImpl::AddZoomLevelChangedCallback(
     const ZoomLevelChangedCallback& callback) {
   return zoom_level_changed_callbacks_.Add(callback);
 }
 
+void HostZoomMapImpl::AddZoomCallback(
+    int zoom_id,
+    const base::Callback<void(void)>& callback) {
+  zoom_callback_map_[zoom_id] = callback;
+}
+
 double HostZoomMapImpl::GetTemporaryZoomLevel(int render_process_id,
                                               int render_view_id) const {
   base::AutoLock auto_lock(lock_);
   for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
     if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
         temporary_zoom_levels_[i].render_view_id == render_view_id) {
       return temporary_zoom_levels_[i].zoom_level;
     }
   }
   return 0;
 }
 
 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id,
                                             int render_view_id,
+                                            const std::string& host,
+                                            int zoom_id,
                                             double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
     base::AutoLock auto_lock(lock_);
     size_t i;
     for (i = 0; i < temporary_zoom_levels_.size(); ++i) {
       if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
           temporary_zoom_levels_[i].render_view_id == render_view_id) {
-        if (level) {
-          temporary_zoom_levels_[i].zoom_level = level;
-        } else {
-          temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
-        }
+        temporary_zoom_levels_[i].zoom_level = level;
         break;
       }
     }
 
     if (level && i == temporary_zoom_levels_.size()) {
       TemporaryZoomLevel temp;
       temp.render_process_id = render_process_id;
       temp.render_view_id = render_view_id;
       temp.zoom_level = level;
       temporary_zoom_levels_.push_back(temp);
     }
   }
 
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
+  change.host = host;
   change.zoom_level = level;
 
+  CallZoomCallback(zoom_id);
   zoom_level_changed_callbacks_.Notify(change);
 }
 
 void HostZoomMapImpl::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: {
       base::AutoLock auto_lock(lock_);
       int render_view_id = Source<RenderViewHost>(source)->GetRoutingID();
       int render_process_id =
           Source<RenderViewHost>(source)->GetProcess()->GetID();
-
-      for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
-        if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
-            temporary_zoom_levels_[i].render_view_id == render_view_id) {
-          temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
-          break;
-        }
-      }
+      EraseTemporaryZoomLevel(render_process_id, render_view_id);
+      break;
+    }
+    case NOTIFICATION_WEB_CONTENTS_NO_TEMPORARY_ZOOM_LEVEL: {
+      base::AutoLock auto_lock(lock_);
+      int render_view_id =
+          Source<WebContents>(source)->GetRenderViewHost()->GetRoutingID();
+      int render_process_id =
+          Source<WebContents>(source)->GetRenderProcessHost()->GetID();
+      EraseTemporaryZoomLevel(render_process_id, render_view_id);
       break;
     }
     default:
       NOTREACHED() << "Unexpected preference observed.";
   }
 }
 
+void HostZoomMapImpl::EraseTemporaryZoomLevel(int render_process_id,
+                                              int render_view_id) {
+  for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
+    if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
+        temporary_zoom_levels_[i].render_view_id == render_view_id) {
+      temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
+      break;
+    }
+  }
+}
+
+void HostZoomMapImpl::CallZoomCallback(int zoom_id) {
+  std::map<int, base::Callback<void(void)> >::iterator it =
+      zoom_callback_map_.find(zoom_id);
+  if (it != zoom_callback_map_.end()) {

[Fady Samuel, 2014/04/10 14:27:25]

Preferred early exit.

if (it == zoom_callback_map_.end())
  return;

[paulmeyer, 2014/04/10 15:11:49]

Done.

+    it->second.Run();
+    zoom_callback_map_.erase(it);
+  }
+}
+
+void HostZoomMapImpl::SendZoomLevelChange(const std::string& scheme,
+                                          const std::string& host,
+                                          double level) {
+  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance()) {
+    RenderProcessHost* render_process_host = i.GetCurrentValue();
+    if (HostZoomMap::GetForBrowserContext(
+            render_process_host->GetBrowserContext()) == this) {
+      int render_process_id = render_process_host->GetID();
+      std::set<int> exceptions;
+      for (size_t i = 0; i != temporary_zoom_levels_.size(); ++i) {
+        if (temporary_zoom_levels_[i].render_process_id == render_process_id) {

[Fady Samuel, 2014/04/10 14:27:25]

Braces unnecessary.

[paulmeyer, 2014/04/10 15:11:49]

Done.

+          exceptions.insert(temporary_zoom_levels_[i].render_view_id);
+        }
+      }
+      render_process_host->Send(new ViewMsg_SetZoomLevelForCurrentURL(
+          scheme, host, level, exceptions));
+    }
+  }
+}
+
 HostZoomMapImpl::~HostZoomMapImpl() {
 }
 
 }  // namespace content