Home | History | Annotate | Download | only in browser 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/plugin_data_remover_impl.h"
      6 
      7 #include <limits>
      8 
      9 #include "base/bind.h"
     10 #include "base/metrics/histogram.h"
     11 #include "base/sequenced_task_runner_helpers.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "base/synchronization/waitable_event.h"
     14 #include "base/version.h"
     15 #include "content/browser/plugin_process_host.h"
     16 #include "content/browser/plugin_service_impl.h"
     17 #include "content/browser/renderer_host/pepper/pepper_flash_file_message_filter.h"
     18 #include "content/common/child_process_host_impl.h"
     19 #include "content/common/plugin_process_messages.h"
     20 #include "content/public/browser/browser_context.h"
     21 #include "content/public/browser/browser_thread.h"
     22 #include "content/public/common/content_constants.h"
     23 #include "content/public/common/pepper_plugin_info.h"
     24 #include "ppapi/proxy/ppapi_messages.h"
     25 
     26 namespace content {
     27 
     28 namespace {
     29 
     30 // The minimum Flash Player version that implements NPP_ClearSiteData.
     31 const char kMinFlashVersion[] = "10.3";
     32 const int64 kRemovalTimeoutMs = 10000;
     33 const uint64 kClearAllData = 0;
     34 
     35 }  // namespace
     36 
     37 // static
     38 PluginDataRemover* PluginDataRemover::Create(BrowserContext* browser_context) {
     39   return new PluginDataRemoverImpl(browser_context);
     40 }
     41 
     42 // static
     43 void PluginDataRemover::GetSupportedPlugins(
     44     std::vector<WebPluginInfo>* supported_plugins) {
     45   bool allow_wildcard = false;
     46   std::vector<WebPluginInfo> plugins;
     47   PluginService::GetInstance()->GetPluginInfoArray(
     48       GURL(), kFlashPluginSwfMimeType, allow_wildcard, &plugins, NULL);
     49   Version min_version(kMinFlashVersion);
     50   for (std::vector<WebPluginInfo>::iterator it = plugins.begin();
     51        it != plugins.end(); ++it) {
     52     Version version;
     53     WebPluginInfo::CreateVersionFromString(it->version, &version);
     54     if (version.IsValid() && min_version.CompareTo(version) == -1)
     55       supported_plugins->push_back(*it);
     56   }
     57 }
     58 
     59 class PluginDataRemoverImpl::Context
     60     : public PluginProcessHost::Client,
     61       public PpapiPluginProcessHost::BrokerClient,
     62       public IPC::Listener,
     63       public base::RefCountedThreadSafe<Context,
     64                                         BrowserThread::DeleteOnIOThread> {
     65  public:
     66   Context(base::Time begin_time, BrowserContext* browser_context)
     67       : event_(new base::WaitableEvent(true, false)),
     68         begin_time_(begin_time),
     69         is_removing_(false),
     70         browser_context_path_(browser_context->GetPath()),
     71         resource_context_(browser_context->GetResourceContext()) {
     72     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     73   }
     74 
     75   void Init(const std::string& mime_type) {
     76     BrowserThread::PostTask(
     77         BrowserThread::IO,
     78         FROM_HERE,
     79         base::Bind(&Context::InitOnIOThread, this, mime_type));
     80     BrowserThread::PostDelayedTask(
     81         BrowserThread::IO,
     82         FROM_HERE,
     83         base::Bind(&Context::OnTimeout, this),
     84         base::TimeDelta::FromMilliseconds(kRemovalTimeoutMs));
     85   }
     86 
     87   void InitOnIOThread(const std::string& mime_type) {
     88     PluginServiceImpl* plugin_service = PluginServiceImpl::GetInstance();
     89 
     90     // Get the plugin file path.
     91     std::vector<WebPluginInfo> plugins;
     92     plugin_service->GetPluginInfoArray(
     93         GURL(), mime_type, false, &plugins, NULL);
     94     base::FilePath plugin_path;
     95     if (!plugins.empty())  // May be empty for some tests.
     96       plugin_path = plugins[0].path;
     97 
     98     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     99     remove_start_time_ = base::Time::Now();
    100     is_removing_ = true;
    101     // Balanced in On[Ppapi]ChannelOpened or OnError. Exactly one them will
    102     // eventually be called, so we need to keep this object around until then.
    103     AddRef();
    104 
    105     PepperPluginInfo* pepper_info =
    106         plugin_service->GetRegisteredPpapiPluginInfo(plugin_path);
    107     if (pepper_info) {
    108       plugin_name_ = pepper_info->name;
    109       // Use the broker since we run this function outside the sandbox.
    110       plugin_service->OpenChannelToPpapiBroker(0, plugin_path, this);
    111     } else {
    112       plugin_service->OpenChannelToNpapiPlugin(
    113           0, 0, GURL(), GURL(), mime_type, this);
    114     }
    115   }
    116 
    117   // Called when a timeout happens in order not to block the client
    118   // indefinitely.
    119   void OnTimeout() {
    120     LOG_IF(ERROR, is_removing_) << "Timed out";
    121     SignalDone();
    122   }
    123 
    124   // PluginProcessHost::Client methods.
    125   virtual int ID() OVERRIDE {
    126     // Generate a unique identifier for this PluginProcessHostClient.
    127     return ChildProcessHostImpl::GenerateChildProcessUniqueId();
    128   }
    129 
    130   virtual bool OffTheRecord() OVERRIDE {
    131     return false;
    132   }
    133 
    134   virtual ResourceContext* GetResourceContext() OVERRIDE {
    135     return resource_context_;
    136   }
    137 
    138   virtual void SetPluginInfo(const WebPluginInfo& info) OVERRIDE {}
    139 
    140   virtual void OnFoundPluginProcessHost(PluginProcessHost* host) OVERRIDE {}
    141 
    142   virtual void OnSentPluginChannelRequest() OVERRIDE {}
    143 
    144   virtual void OnChannelOpened(const IPC::ChannelHandle& handle) OVERRIDE {
    145     ConnectToChannel(handle, false);
    146     // Balancing the AddRef call.
    147     Release();
    148   }
    149 
    150   virtual void OnError() OVERRIDE {
    151     LOG(ERROR) << "Couldn't open plugin channel";
    152     SignalDone();
    153     // Balancing the AddRef call.
    154     Release();
    155   }
    156 
    157   // PpapiPluginProcessHost::BrokerClient implementation.
    158   virtual void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
    159                                    int* renderer_id) OVERRIDE {
    160     *renderer_handle = base::kNullProcessHandle;
    161     *renderer_id = 0;
    162   }
    163 
    164   virtual void OnPpapiChannelOpened(
    165       const IPC::ChannelHandle& channel_handle,
    166       base::ProcessId  /* peer_pid */,
    167       int /* child_id */) OVERRIDE {
    168     if (!channel_handle.name.empty())
    169       ConnectToChannel(channel_handle, true);
    170 
    171     // Balancing the AddRef call.
    172     Release();
    173   }
    174 
    175   // IPC::Listener methods.
    176   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
    177     IPC_BEGIN_MESSAGE_MAP(Context, message)
    178       IPC_MESSAGE_HANDLER(PluginProcessHostMsg_ClearSiteDataResult,
    179                           OnClearSiteDataResult)
    180       IPC_MESSAGE_HANDLER(PpapiHostMsg_ClearSiteDataResult,
    181                           OnPpapiClearSiteDataResult)
    182       IPC_MESSAGE_UNHANDLED_ERROR()
    183     IPC_END_MESSAGE_MAP()
    184 
    185     return true;
    186   }
    187 
    188   virtual void OnChannelError() OVERRIDE {
    189     if (is_removing_) {
    190       NOTREACHED() << "Channel error";
    191       SignalDone();
    192     }
    193   }
    194 
    195   base::WaitableEvent* event() { return event_.get(); }
    196 
    197  private:
    198   friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
    199   friend class base::DeleteHelper<Context>;
    200   virtual ~Context() {}
    201 
    202   IPC::Message* CreatePpapiClearSiteDataMsg(uint64 max_age) {
    203     base::FilePath profile_path =
    204         PepperFlashFileMessageFilter::GetDataDirName(browser_context_path_);
    205     // TODO(vtl): This "duplicates" logic in webkit/plugins/ppapi/file_path.cc
    206     // (which prepends the plugin name to the relative part of the path
    207     // instead, with the absolute, profile-dependent part being enforced by
    208     // the browser).
    209 #if defined(OS_WIN)
    210     base::FilePath plugin_data_path =
    211         profile_path.Append(base::FilePath(UTF8ToUTF16(plugin_name_)));
    212 #else
    213     base::FilePath plugin_data_path =
    214         profile_path.Append(base::FilePath(plugin_name_));
    215 #endif  // defined(OS_WIN)
    216     return new PpapiMsg_ClearSiteData(0u, plugin_data_path, std::string(),
    217                                       kClearAllData, max_age);
    218   }
    219 
    220   // Connects the client side of a newly opened plug-in channel.
    221   void ConnectToChannel(const IPC::ChannelHandle& handle, bool is_ppapi) {
    222     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    223 
    224     // If we timed out, don't bother connecting.
    225     if (!is_removing_)
    226       return;
    227 
    228     DCHECK(!channel_.get());
    229     channel_.reset(new IPC::Channel(handle, IPC::Channel::MODE_CLIENT, this));
    230     if (!channel_->Connect()) {
    231       NOTREACHED() << "Couldn't connect to plugin";
    232       SignalDone();
    233       return;
    234     }
    235 
    236     uint64 max_age = begin_time_.is_null() ?
    237         std::numeric_limits<uint64>::max() :
    238         (base::Time::Now() - begin_time_).InSeconds();
    239 
    240     IPC::Message* msg;
    241     if (is_ppapi) {
    242       msg = CreatePpapiClearSiteDataMsg(max_age);
    243     } else {
    244       msg = new PluginProcessMsg_ClearSiteData(
    245           std::string(), kClearAllData, max_age);
    246     }
    247     if (!channel_->Send(msg)) {
    248       NOTREACHED() << "Couldn't send ClearSiteData message";
    249       SignalDone();
    250       return;
    251     }
    252   }
    253 
    254   // Handles the PpapiHostMsg_ClearSiteDataResult message by delegating to the
    255   // PluginProcessHostMsg_ClearSiteDataResult handler.
    256   void OnPpapiClearSiteDataResult(uint32 request_id, bool success) {
    257     DCHECK_EQ(0u, request_id);
    258     OnClearSiteDataResult(success);
    259   }
    260 
    261   // Handles the PluginProcessHostMsg_ClearSiteDataResult message.
    262   void OnClearSiteDataResult(bool success) {
    263     LOG_IF(ERROR, !success) << "ClearSiteData returned error";
    264     UMA_HISTOGRAM_TIMES("ClearPluginData.time",
    265                         base::Time::Now() - remove_start_time_);
    266     SignalDone();
    267   }
    268 
    269   // Signals that we are finished with removing data (successful or not). This
    270   // method is safe to call multiple times.
    271   void SignalDone() {
    272     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    273     if (!is_removing_)
    274       return;
    275     is_removing_ = false;
    276     event_->Signal();
    277   }
    278 
    279   scoped_ptr<base::WaitableEvent> event_;
    280   // The point in time when we start removing data.
    281   base::Time remove_start_time_;
    282   // The point in time from which on we remove data.
    283   base::Time begin_time_;
    284   bool is_removing_;
    285 
    286   // Path for the current profile. Must be retrieved on the UI thread from the
    287   // browser context when we start so we can use it later on the I/O thread.
    288   base::FilePath browser_context_path_;
    289 
    290   // The resource context for the profile. Use only on the I/O thread.
    291   ResourceContext* resource_context_;
    292 
    293   // The name of the plugin. Use only on the I/O thread.
    294   std::string plugin_name_;
    295 
    296   // The channel is NULL until we have opened a connection to the plug-in
    297   // process.
    298   scoped_ptr<IPC::Channel> channel_;
    299 };
    300 
    301 
    302 PluginDataRemoverImpl::PluginDataRemoverImpl(BrowserContext* browser_context)
    303     : mime_type_(kFlashPluginSwfMimeType),
    304       browser_context_(browser_context) {
    305 }
    306 
    307 PluginDataRemoverImpl::~PluginDataRemoverImpl() {
    308 }
    309 
    310 base::WaitableEvent* PluginDataRemoverImpl::StartRemoving(
    311     base::Time begin_time) {
    312   DCHECK(!context_.get());
    313   context_ = new Context(begin_time, browser_context_);
    314   context_->Init(mime_type_);
    315   return context_->event();
    316 }
    317 
    318 }  // namespace content
    319