Android: Remove more browser extensions code, including some that snuck back in.

chrome/browser/performance_monitor/performance_monitor.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/performance_monitor/performance_monitor.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/process/process_iterator.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/performance_monitor_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
-#include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/browser_child_process_host.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/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents.h"
-#include "extensions/common/extension.h"
 #include "net/url_request/url_request.h"
 
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/crx_installer.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "extensions/common/extension.h"
+#endif
+
 using content::BrowserThread;
+
+#if defined(ENABLE_EXTENSIONS)
 using extensions::Extension;
 using extensions::UnloadedExtensionInfo;
+#endif
 
 namespace performance_monitor {
 
 namespace {
 
 #if !defined(OS_ANDROID)
 std::string TimeToString(base::Time time) {
   int64 time_int64 = time.ToInternalValue();
   return base::Int64ToString(time_int64);
 }
@@ skipping 334 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&PerformanceMonitor::GatherMetricsMapOnIOThread,
                  base::Unretained(this),
                  current_update_sequence));
 }
 
 void PerformanceMonitor::MarkProcessAsAlive(const base::ProcessHandle& handle,
                                         int process_type,
                                         int current_update_sequence) {
-
   if (handle == 0) {
     // Process may not be valid yet.
     return;
   }
 
   MetricsMap::iterator process_metrics_iter = metrics_map_.find(handle);
   if (process_metrics_iter == metrics_map_.end()) {
     // If we're not already watching the process, let's initialize it.
     metrics_map_[handle]
         .Initialize(handle, process_type, current_update_sequence);
@@ skipping 139 matching lines @@
   if (initialized_ && !request.url().SchemeIsFile())
     performance_data_for_io_thread_.network_bytes_read += bytes_read;
 }
 
 void PerformanceMonitor::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   DCHECK(database_logging_enabled_);
 
   switch (type) {
+#if defined(ENABLE_EXTENSIONS)
     case extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
       AddExtensionEvent(
           EVENT_EXTENSION_INSTALL,
           content::Details<const extensions::InstalledExtensionInfo>(details)->
               extension);
       break;
     }
     case extensions::NOTIFICATION_EXTENSION_ENABLED: {
       AddExtensionEvent(EVENT_EXTENSION_ENABLE,
                         content::Details<Extension>(details).ptr());
@@ skipping 22 matching lines @@
           installer->install_cause() == extension_misc::INSTALL_CAUSE_UPDATE) {
         AddExtensionEvent(EVENT_EXTENSION_UPDATE, extension);
       }
       break;
     }
     case extensions::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED: {
       AddExtensionEvent(EVENT_EXTENSION_UNINSTALL,
                         content::Details<Extension>(details).ptr());
       break;
     }
+#endif  // defined(ENABLE_EXTENSIONS)
     case content::NOTIFICATION_RENDER_WIDGET_HOST_HANG: {
       std::string url;
       content::RenderWidgetHost* widget =
           content::Source<content::RenderWidgetHost>(source).ptr();
       if (widget->IsRenderView()) {
         content::RenderViewHost* view = content::RenderViewHost::From(widget);
         MaybeGetURLFromRenderView(view, &url);
       }
       AddEvent(util::CreateRendererFailureEvent(base::Time::Now(),
                                                 EVENT_RENDERER_HANG,
@@ skipping 37 matching lines @@
                          load_details->load_time.ToInternalValue()))));
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
+#if defined(ENABLE_EXTENSIONS)
 void PerformanceMonitor::AddExtensionEvent(EventType type,
-                                              const Extension* extension) {
+                                           const Extension* extension) {
   DCHECK(type == EVENT_EXTENSION_INSTALL ||
          type == EVENT_EXTENSION_UNINSTALL ||
          type == EVENT_EXTENSION_UPDATE ||
          type == EVENT_EXTENSION_ENABLE ||
          type == EVENT_EXTENSION_DISABLE);
   AddEvent(util::CreateExtensionEvent(type,
                                       base::Time::Now(),
                                       extension->id(),
                                       extension->name(),
                                       extension->url().spec(),
                                       extension->location(),
                                       extension->VersionString(),
                                       extension->description()));
 }
+#endif  // defined(ENABLE_EXTENSIONS)
 
 void PerformanceMonitor::AddRendererClosedEvent(
     content::RenderProcessHost* host,
     const content::RenderProcessHost::RendererClosedDetails& details) {
   // We only care if this is an invalid termination.
   if (details.status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
       details.status == base::TERMINATION_STATUS_STILL_RUNNING)
     return;
 
   // Determine the type of crash.
@@ skipping 21 matching lines @@
     if (!url_list.empty())
       url_list += ", ";
 
     url_list += url;
   }
 
   AddEvent(util::CreateRendererFailureEvent(base::Time::Now(), type, url_list));
 }
 
 }  // namespace performance_monitor