Change the view mode when switching between moles and toolstrips, and

chrome/renderer/resources/extension_process_bindings.js

 // Copyright (c) 2009 The chrome Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // -----------------------------------------------------------------------------
 // NOTE: If you change this file you need to touch renderer_resources.grd to
 // have your change take effect.
 // -----------------------------------------------------------------------------
 
 // This script contains privileged chrome extension related javascript APIs.
@@ skipping 97 matching lines @@
         } else {
           request.callback();
         }
       }
     } finally {
       delete requests[requestId];
       delete chrome.extension.lastError;
     }
   };
 
+  chromeHidden.setViewType = function(type) {
+    var modeClass = "chrome-" + type;
+    var className = document.documentElement.className;
+    if (className && className.length) {
+      var classes = className.split(" ");
+      var new_classes = [];
+      classes.forEach(function(cls) {
+        if (cls.indexOf("chrome-") != 0) {
+          new_classes.push(cls);
+        }
+      });
+      new_classes.push(modeClass);
+      document.documentElement.className = new_classes.join(" ");
+    } else {
+      document.documentElement.className = modeClass;
+    }
+  };
+
   function prepareRequest(args, argSchemas) {
     var request = {};
     var argCount = args.length;
 
     // Look for callback param.
     if (argSchemas.length > 0 &&
         args.length == argSchemas.length &&
         argSchemas[argSchemas.length - 1].type == "function") {
       request.callback = args[argSchemas.length - 1];
       request.callbackSchema = argSchemas[argSchemas.length - 1];
@@ skipping 21 matching lines @@
     // JSON.stringify doesn't support a root object which is undefined.
     if (request.args === undefined)
       request.args = null;
     var sargs = JSON.stringify(request.args);
     var requestId = GetNextRequestId();
     requests[requestId] = request;
     return StartRequest(functionName, sargs, requestId,
                         request.callback ? true : false);
   }
 
-  // Using forEach for convenience, and to bind |module|s & |apiDefs|s via
-  // closures.
-  function forEach(a, f) {
-    for (var i = 0; i < a.length; i++) {
-      f(a[i], i);
-    }
-  }
-
   function bind(obj, func) {
     return function() {
       return func.apply(obj, arguments);
     };
   }
 
   // --- Setup additional api's not currently handled in common/extensions/api
 
   // Page action events send (pageActionId, {tabId, tabUrl}).
   function setupPageActionEvents(extensionId) {
@@ skipping 27 matching lines @@
     var apiFunctions = {};
 
     // Read api definitions and setup api functions in the chrome namespace.
     // TODO(rafaelw): Consider defining a json schema for an api definition
     //   and validating either here, in a unit_test or both.
     // TODO(rafaelw): Handle synchronous functions.
     // TOOD(rafaelw): Consider providing some convenient override points
     //   for api functions that wish to insert themselves into the call.
     var apiDefinitions = JSON.parse(GetExtensionAPIDefinition());
 
-    forEach(apiDefinitions, function(apiDef) {
+    apiDefinitions.forEach(function(apiDef) {
       chrome[apiDef.namespace] = chrome[apiDef.namespace] || {};
       var module = chrome[apiDef.namespace];
 
       // Add types to global validationTypes
       if (apiDef.types) {
-        forEach(apiDef.types, function(t) {
+        apiDef.types.forEach(function(t) {
           chromeHidden.validationTypes.push(t);
         });
       }
 
       // Setup Functions.
       if (apiDef.functions) {
-        forEach(apiDef.functions, function(functionDef) {
+        apiDef.functions.forEach(function(functionDef) {
           // Module functions may have been defined earlier by hand. Don't
           // clobber them.
           if (module[functionDef.name])
             return;
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
           apiFunction.name = apiDef.namespace + "." + functionDef.name;;
           apiFunctions[apiFunction.name] = apiFunction;
 
           module[functionDef.name] = bind(apiFunction, function() {
             chromeHidden.validate(arguments, this.definition.parameters);
 
             if (this.handleRequest)
               return this.handleRequest.apply(this, arguments);
             else
               return sendRequest(this.name, arguments,
                   this.definition.parameters);
           });
         });
       }
 
       // Setup Events
       if (apiDef.events) {
-        forEach(apiDef.events, function(eventDef) {
+        apiDef.events.forEach(function(eventDef) {
           // Module events may have been defined earlier by hand. Don't clobber
           // them.
           if (module[eventDef.name])
             return;
 
           var eventName = apiDef.namespace + "." + eventDef.name;
           module[eventDef.name] = new chrome.Event(eventName,
               eventDef.parameters);
         });
       }
@@ skipping 26 matching lines @@
 
     apiFunctions["extension.getTabContentses"].handleRequest =
         function(windowId) {
       if (typeof(windowId) == "undefined")
         windowId = -1;
       return GetExtensionViews(windowId, "TAB");
     }
 
     apiFunctions["devtools.getTabEvents"].handleRequest = function(tabId) {
       var tabIdProxy = {};
-      forEach(["onPageEvent", "onTabUrlChange", "onTabClose"],
-              function(name) {
+      var functions = ["onPageEvent", "onTabUrlChange", "onTabClose"];
+      functions.forEach(function(name) {
         // Event disambiguation is handled by name munging.  See
         // chrome/browser/extensions/extension_devtools_events.h for the C++
         // equivalent of this logic.
         tabIdProxy[name] = new chrome.Event("devtools." + tabId + "." + name);
       });
       return tabIdProxy;
     }
 
     setupPageActionEvents(extensionId);
     setupToolstripEvents(GetRenderViewId());
   });
 })();