Update our use of the NPAPI ClearSiteData API.

chrome/browser/plugin_data_remover.cc

 // Copyright (c) 2010 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/plugin_data_remover.h"
 
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/version.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/common/plugin_messages.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 namespace {
-const char* g_flash_mime_type = "application/x-shockwave-flash";
+const char* kFlashMimeType = "application/x-shockwave-flash";
 // TODO(bauerb): Update minimum required Flash version as soon as there is one
 // implementing the API.
-const char* g_min_flash_version = "100";
-const int64 g_timeout_ms = 10000;
+const char* kMinFlashVersion = "100";
+const int64 kRemovalTimeoutMs = 10000;
+const uint64 kClearAllData = 0;
 }  // namespace
 
 PluginDataRemover::PluginDataRemover()
     : is_removing_(false),
       channel_(NULL) { }
 
 PluginDataRemover::~PluginDataRemover() {
   DCHECK(!is_removing_);
   if (channel_)
     BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, channel_);
 }
 
 void PluginDataRemover::StartRemoving(base::Time begin_time, Task* done_task) {
   DCHECK(!done_task_.get());
   DCHECK(!is_removing_);
   remove_start_time_ = base::Time::Now();
   begin_time_ = begin_time;
 
   message_loop_ = base::MessageLoopProxy::CreateForCurrentThread();
   done_task_.reset(done_task);
   is_removing_ = true;
 
   AddRef();
   PluginService::GetInstance()->OpenChannelToPlugin(
-      GURL(), g_flash_mime_type, this);
+      GURL(), kFlashMimeType, this);
 
   BrowserThread::PostDelayedTask(
       BrowserThread::IO,
       FROM_HERE,
       NewRunnableMethod(this, &PluginDataRemover::OnTimeout),
-      g_timeout_ms);
+      kRemovalTimeoutMs);
 }
 
 int PluginDataRemover::ID() {
   // Generate an ID for the browser process.
   return ChildProcessInfo::GenerateChildProcessUniqueId();
 }
 
 bool PluginDataRemover::OffTheRecord() {
   return false;
 }
@@ skipping 16 matching lines @@
 
   DCHECK(!channel_);
   channel_ = new IPC::Channel(handle, IPC::Channel::MODE_CLIENT, this);
   if (!channel_->Connect()) {
     LOG(DFATAL) << "Couldn't connect to plugin";
     SignalDone();
     return;
   }
 
   if (!channel_->Send(
-          new PluginMsg_ClearSiteData(0, std::string(), begin_time_))) {
+          new PluginMsg_ClearSiteData(std::string(),
+                                      kClearAllData,
+                                      begin_time_))) {
     LOG(DFATAL) << "Couldn't send ClearSiteData message";
     SignalDone();
   }
 }
 
 void PluginDataRemover::OnError() {
   NOTREACHED() << "Couldn't open plugin channel";
   SignalDone();
   Release();
 }
@@ skipping 36 matching lines @@
     message_loop_ = NULL;
   }
 }
 
 // static
 bool PluginDataRemover::IsSupported() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   bool allow_wildcard = false;
   webkit::npapi::WebPluginInfo plugin;
   std::string mime_type;
-  if (!webkit::npapi::PluginList::Singleton()->GetPluginInfo(GURL(),
-                                                             g_flash_mime_type,
-                                                             allow_wildcard,
-                                                             &plugin,
-                                                             &mime_type))
+  if (!webkit::npapi::PluginList::Singleton()->GetPluginInfo(
+          GURL(), kFlashMimeType, allow_wildcard, &plugin, &mime_type)) {
     return false;
+  }
   scoped_ptr<Version> version(
       webkit::npapi::PluginGroup::CreateVersionFromString(plugin.version));
   scoped_ptr<Version> min_version(
-      Version::GetVersionFromString(g_min_flash_version));
+      Version::GetVersionFromString(kMinFlashVersion));
   return plugin.enabled &&
          version.get() &&
          min_version->CompareTo(*version) == -1;
 }