ifdef various extensions code to be used only when extensions are enabled.

chrome/browser/memory_details.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/memory_details.h"
 
 #include "base/bind.h"
 #include "base/file_version_info.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/bindings_policy.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/browser/process_manager.h"
-#include "extensions/browser/process_map.h"
-#include "extensions/browser/view_type_utils.h"
-#include "extensions/common/extension.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #include "content/public/browser/zygote_host_linux.h"
 #endif
 
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/extension_service.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/process_manager.h"
+#include "extensions/browser/process_map.h"
+#include "extensions/browser/view_type_utils.h"
+#include "extensions/common/extension.h"
+#endif
+
 using base::StringPrintf;
 using content::BrowserChildProcessHostIterator;
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
+#if defined(ENABLE_EXTENSIONS)
 using extensions::Extension;
+#endif
 
 // static
 std::string ProcessMemoryInformation::GetRendererTypeNameInEnglish(
     RendererProcessType type) {
   switch (type) {
     case RENDERER_NORMAL:
       return "Tab";
     case RENDERER_CHROME:
       return "Tab (Chrome)";
     case RENDERER_EXTENSION:
@@ skipping 203 matching lines @@
         RenderWidgetHost::GetRenderWidgetHosts());
     while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
       content::RenderProcessHost* render_process_host =
           widget->GetProcess();
       DCHECK(render_process_host);
       // Ignore processes that don't have a connection, such as crashed tabs.
       if (!render_process_host->HasConnection() ||
           process.pid != base::GetProcId(render_process_host->GetHandle())) {
         continue;
       }
-      process.process_type = content::PROCESS_TYPE_RENDERER;
-      content::BrowserContext* context =
-          render_process_host->GetBrowserContext();
-      ExtensionService* extension_service =
-          extensions::ExtensionSystem::Get(context)->extension_service();
-      extensions::ProcessMap* extension_process_map = NULL;
-      // No extensions on Android. So extension_service can be NULL.
-      if (extension_service)
-        extension_process_map = extensions::ProcessMap::Get(context);
 
       // The RenderProcessHost may host multiple WebContentses.  Any
       // of them which contain diagnostics information make the whole
       // process be considered a diagnostics process.
       if (!widget->IsRenderView())
         continue;
 
+      process.process_type = content::PROCESS_TYPE_RENDERER;
+      bool is_extension = false;
       RenderViewHost* host = RenderViewHost::From(widget);
+#if defined(ENABLE_EXTENSIONS)
+      content::BrowserContext* context =
+          render_process_host->GetBrowserContext();
+      ExtensionService* extension_service =
+          extensions::ExtensionSystem::Get(context)->extension_service();
+      extensions::ProcessMap* extension_process_map =
+          extensions::ProcessMap::Get(context);
+      is_extension = extension_process_map->Contains(
+          host->GetProcess()->GetID());
+#endif
+
       WebContents* contents = WebContents::FromRenderViewHost(host);
       GURL url;
       if (contents) {
         url = contents->GetURL();
         SiteData* site_data =
             &chrome_browser->site_data[contents->GetBrowserContext()];
         SiteDetails::CollectSiteInfo(contents, site_data);
       }
+#if defined(ENABLE_EXTENSIONS)
       extensions::ViewType type = extensions::GetViewType(contents);
+#endif
       if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
         process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
-      } else if (extension_process_map &&
-                 extension_process_map->Contains(host->GetProcess()->GetID())) {
+      } else if (is_extension) {
+#if defined(ENABLE_EXTENSIONS)
         // For our purposes, don't count processes containing only hosted apps
         // as extension processes. See also: crbug.com/102533.
         std::set<std::string> extension_ids =
             extension_process_map->GetExtensionsInProcess(
             host->GetProcess()->GetID());
         for (std::set<std::string>::iterator iter = extension_ids.begin();
              iter != extension_ids.end(); ++iter) {
           const Extension* extension =
               extension_service->GetExtensionById(*iter, false);
           if (extension && !extension->is_hosted_app()) {
             process.renderer_type =
                 ProcessMemoryInformation::RENDERER_EXTENSION;
             break;
           }
         }
+#endif
       }
-      if (extension_process_map &&
-          extension_process_map->Contains(host->GetProcess()->GetID())) {
+#if defined(ENABLE_EXTENSIONS)
+      if (is_extension) {
         const Extension* extension =
             extension_service->extensions()->GetByID(url.host());
         if (extension) {
           base::string16 title = base::UTF8ToUTF16(extension->name());
           process.titles.push_back(title);
           process.renderer_type =
               ProcessMemoryInformation::RENDERER_EXTENSION;
           continue;
         }
       }
+#endif
 
       if (!contents) {
         process.renderer_type =
             ProcessMemoryInformation::RENDERER_INTERSTITIAL;
         continue;
       }
 
+#if defined(ENABLE_EXTENSIONS)
       if (type == extensions::VIEW_TYPE_BACKGROUND_CONTENTS) {
         process.titles.push_back(base::UTF8ToUTF16(url.spec()));
         process.renderer_type =
             ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
         continue;
       }
+#endif
 
       // Since we have a WebContents and and the renderer type hasn't been
       // set yet, it must be a normal tabbed renderer.
       if (process.renderer_type == ProcessMemoryInformation::RENDERER_UNKNOWN)
         process.renderer_type = ProcessMemoryInformation::RENDERER_NORMAL;
 
       base::string16 title = contents->GetTitle();
       if (!title.length())
         title = l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
       process.titles.push_back(title);
@@ skipping 271 matching lines @@
 
   if (swap_info_.orig_data_size > 0 && swap_info_.compr_data_size > 0) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Memory.Swap.CompressionRatio",
         swap_info_.orig_data_size / swap_info_.compr_data_size,
         1, 20, 20);
   }
 }
 
 #endif