Move remaining files in content\browser to the content namespace.

content/browser/power_save_blocker_win.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/power_save_blocker.h"
 
 #include <windows.h>
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "content/public/browser/browser_thread.h"
 
+namespace content {
 namespace {
 
 int g_blocker_count[2];
 
 HANDLE CreatePowerRequest(POWER_REQUEST_TYPE type, const std::string& reason) {
   typedef HANDLE (WINAPI* PowerCreateRequestPtr)(PREASON_CONTEXT);
   typedef BOOL (WINAPI* PowerSetRequestPtr)(HANDLE, POWER_REQUEST_TYPE);
 
   if (type == PowerRequestExecutionRequired &&
       base::win::GetVersion() < base::win::VERSION_WIN8) {
@@ skipping 47 matching lines @@
       reinterpret_cast<PowerClearRequestPtr>(
           GetProcAddress(module, "PowerClearRequest"));
 
   if (!PowerClearRequestFn)
     return;
 
   BOOL success = PowerClearRequestFn(request_handle, type);
   DCHECK(success);
 }
 
-void ApplySimpleBlock(content::PowerSaveBlocker::PowerSaveBlockerType type,
+void ApplySimpleBlock(PowerSaveBlocker::PowerSaveBlockerType type,
                       int delta) {

[tfarina, 2012/10/30 22:19:06]

probably fits above now.

   g_blocker_count[type] += delta;
   DCHECK_GE(g_blocker_count[type], 0);
 
   if (g_blocker_count[type] > 1)
     return;
 
   DWORD this_flag = 0;
-  if (type == content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension)
+  if (type == PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension)
     this_flag |= ES_SYSTEM_REQUIRED;
   else
     this_flag |= ES_DISPLAY_REQUIRED;
 
   DCHECK(this_flag);
 
   static DWORD flags = ES_CONTINUOUS;
   if (!g_blocker_count[type])
     flags &= ~this_flag;
   else
     flags |= this_flag;
 
   SetThreadExecutionState(flags);
 }
 
 }  // namespace.
 
-namespace content {
-
 class PowerSaveBlocker::Delegate
     : public base::RefCountedThreadSafe<PowerSaveBlocker::Delegate> {
  public:
   Delegate(PowerSaveBlockerType type, const std::string& reason)
       : type_(type), reason_(reason) {}
 
   // Does the actual work to apply or remove the desired power save block.
   void ApplyBlock();
   void RemoveBlock();
 
@@ skipping 45 matching lines @@
       base::Bind(&Delegate::ApplyBlock, delegate_));
 }
 
 PowerSaveBlocker::~PowerSaveBlocker() {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Delegate::RemoveBlock, delegate_));
 }
 
 }  // namespace content