content/browser/worker_host/worker_service_impl.cc

   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/worker_host/worker_service_impl.h"
   6
   7 #include <string>
   8
   9 #include "base/command_line.h"
  10 #include "base/logging.h"
  11 #include "base/threading/thread.h"
  12 #include "content/browser/devtools/worker_devtools_manager.h"
  13 #include "content/browser/renderer_host/render_widget_host_impl.h"
  14 #include "content/browser/shared_worker/shared_worker_service_impl.h"
  15 #include "content/browser/worker_host/worker_message_filter.h"
  16 #include "content/browser/worker_host/worker_process_host.h"
  17 #include "content/common/view_messages.h"
  18 #include "content/common/worker_messages.h"
  19 #include "content/public/browser/child_process_data.h"
  20 #include "content/public/browser/notification_service.h"
  21 #include "content/public/browser/notification_types.h"
  22 #include "content/public/browser/render_frame_host.h"
  23 #include "content/public/browser/render_process_host.h"
  24 #include "content/public/browser/render_view_host.h"
  25 #include "content/public/browser/render_widget_host.h"
  26 #include "content/public/browser/render_widget_host_iterator.h"
  27 #include "content/public/browser/render_widget_host_view.h"
  28 #include "content/public/browser/resource_context.h"
  29 #include "content/public/browser/web_contents.h"
  30 #include "content/public/browser/worker_service_observer.h"
  31 #include "content/public/common/content_switches.h"
  32 #include "content/public/common/process_type.h"
  33
  34 namespace content {
  35
  36 namespace {
  37 void AddRenderFrameID(std::set<std::pair<int, int> >* visible_frame_ids,
  38                       RenderFrameHost* rfh) {
  39   visible_frame_ids->insert(
  40       std::pair<int, int>(rfh->GetProcess()->GetID(),
  41                           rfh->GetRoutingID()));
  42 }
  43 }
  44
  45 const int WorkerServiceImpl::kMaxWorkersWhenSeparate = 64;
  46 const int WorkerServiceImpl::kMaxWorkersPerFrameWhenSeparate = 16;
  47
  48 class WorkerPrioritySetter
  49     : public NotificationObserver,
  50       public base::RefCountedThreadSafe<WorkerPrioritySetter,
  51                                         BrowserThread::DeleteOnUIThread> {
  52  public:
  53   WorkerPrioritySetter();
  54
  55   // Posts a task to the UI thread to register to receive notifications.
  56   void Initialize();
  57
  58   // Invoked by WorkerServiceImpl when a worker process is created.
  59   void NotifyWorkerProcessCreated();
  60
  61  private:
  62   friend class base::RefCountedThreadSafe<WorkerPrioritySetter>;
  63   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
  64   friend class base::DeleteHelper<WorkerPrioritySetter>;
  65   virtual ~WorkerPrioritySetter();
  66
  67   // Posts a task to perform a worker priority update.
  68   void PostTaskToGatherAndUpdateWorkerPriorities();
  69
  70   // Gathers up a list of the visible tabs and then updates priorities for
  71   // all the shared workers.
  72   void GatherVisibleIDsAndUpdateWorkerPriorities();
  73
  74   // Registers as an observer to receive notifications about
  75   // widgets being shown.
  76   void RegisterObserver();
  77
  78   // Sets priorities for shared workers given a set of visible frames (as a
  79   // std::set of std::pair<render_process, render_frame> ids.
  80   void UpdateWorkerPrioritiesFromVisibleSet(
  81       const std::set<std::pair<int, int> >* visible);
  82
  83   // Called to refresh worker priorities when focus changes between tabs.
  84   void OnRenderWidgetVisibilityChanged(std::pair<int, int>);
  85
  86   // NotificationObserver implementation.
  87   virtual void Observe(int type,
  88                        const NotificationSource& source,
  89                        const NotificationDetails& details) OVERRIDE;
  90
  91   NotificationRegistrar registrar_;
  92 };
  93
  94 WorkerPrioritySetter::WorkerPrioritySetter() {
  95 }
  96
  97 WorkerPrioritySetter::~WorkerPrioritySetter() {
  98   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  99 }
 100
 101 void WorkerPrioritySetter::Initialize() {
 102   BrowserThread::PostTask(
 103       BrowserThread::UI, FROM_HERE,
 104       base::Bind(&WorkerPrioritySetter::RegisterObserver, this));
 105 }
 106
 107 void WorkerPrioritySetter::NotifyWorkerProcessCreated() {
 108   PostTaskToGatherAndUpdateWorkerPriorities();
 109 }
 110
 111 void WorkerPrioritySetter::PostTaskToGatherAndUpdateWorkerPriorities() {
 112   BrowserThread::PostTask(
 113       BrowserThread::UI, FROM_HERE,
 114       base::Bind(
 115           &WorkerPrioritySetter::GatherVisibleIDsAndUpdateWorkerPriorities,
 116           this));
 117 }
 118
 119 void WorkerPrioritySetter::GatherVisibleIDsAndUpdateWorkerPriorities() {
 120   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 121   std::set<std::pair<int, int> >* visible_frame_ids =
 122       new std::set<std::pair<int, int> >();
 123
 124   // Gather up all the visible renderer process/view pairs
 125   scoped_ptr<RenderWidgetHostIterator> widgets(
 126       RenderWidgetHost::GetRenderWidgetHosts());
 127   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
 128     if (widget->GetProcess()->VisibleWidgetCount() == 0)
 129       continue;
 130     if (!widget->IsRenderView())
 131       continue;
 132
 133     RenderWidgetHostView* widget_view = widget->GetView();
 134     if (!widget_view || !widget_view->IsShowing())
 135       continue;
 136     RenderViewHost* rvh = RenderViewHost::From(widget);
 137     WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
 138     if (!web_contents)
 139       continue;
 140     web_contents->ForEachFrame(
 141         base::Bind(&AddRenderFrameID, visible_frame_ids));
 142   }
 143
 144   BrowserThread::PostTask(
 145       BrowserThread::IO, FROM_HERE,
 146       base::Bind(&WorkerPrioritySetter::UpdateWorkerPrioritiesFromVisibleSet,
 147                  this, base::Owned(visible_frame_ids)));
 148 }
 149
 150 void WorkerPrioritySetter::UpdateWorkerPrioritiesFromVisibleSet(
 151     const std::set<std::pair<int, int> >* visible_frame_ids) {
 152   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 153
 154   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 155     if (!iter->process_launched())
 156       continue;
 157     bool throttle = true;
 158
 159     for (WorkerProcessHost::Instances::const_iterator instance =
 160         iter->instances().begin(); instance != iter->instances().end();
 161         ++instance) {
 162
 163       // This code assumes one worker per process
 164       WorkerProcessHost::Instances::const_iterator first_instance =
 165           iter->instances().begin();
 166       if (first_instance == iter->instances().end())
 167         continue;
 168
 169       WorkerDocumentSet::DocumentInfoSet::const_iterator info =
 170           first_instance->worker_document_set()->documents().begin();
 171
 172       for (; info != first_instance->worker_document_set()->documents().end();
 173           ++info) {
 174         std::pair<int, int> id(
 175             info->render_process_id(), info->render_frame_id());
 176         if (visible_frame_ids->find(id) != visible_frame_ids->end()) {
 177           throttle = false;
 178           break;
 179         }
 180       }
 181
 182       if (!throttle ) {
 183         break;
 184       }
 185     }
 186
 187     iter->SetBackgrounded(throttle);
 188   }
 189 }
 190
 191 void WorkerPrioritySetter::OnRenderWidgetVisibilityChanged(
 192     std::pair<int, int> id) {
 193   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 194   std::set<std::pair<int, int> > visible_frame_ids;
 195
 196   visible_frame_ids.insert(id);
 197
 198   UpdateWorkerPrioritiesFromVisibleSet(&visible_frame_ids);
 199 }
 200
 201 void WorkerPrioritySetter::RegisterObserver() {
 202   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 203   registrar_.Add(this, NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
 204                  NotificationService::AllBrowserContextsAndSources());
 205   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CREATED,
 206                  NotificationService::AllBrowserContextsAndSources());
 207 }
 208
 209 void WorkerPrioritySetter::Observe(int type,
 210     const NotificationSource& source, const NotificationDetails& details) {
 211   if (type == NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
 212     bool visible = *Details<bool>(details).ptr();
 213
 214     if (visible) {
 215       int render_widget_id =
 216           Source<RenderWidgetHost>(source).ptr()->GetRoutingID();
 217       int render_process_pid =
 218           Source<RenderWidgetHost>(source).ptr()->GetProcess()->GetID();
 219
 220       BrowserThread::PostTask(
 221           BrowserThread::IO, FROM_HERE,
 222           base::Bind(&WorkerPrioritySetter::OnRenderWidgetVisibilityChanged,
 223               this, std::pair<int, int>(render_process_pid, render_widget_id)));
 224     }
 225   }
 226   else if (type == NOTIFICATION_RENDERER_PROCESS_CREATED) {
 227     PostTaskToGatherAndUpdateWorkerPriorities();
 228   }
 229 }
 230
 231 WorkerService* WorkerService::GetInstance() {
 232   if (EmbeddedSharedWorkerEnabled())
 233     return SharedWorkerServiceImpl::GetInstance();
 234   else
 235     return WorkerServiceImpl::GetInstance();
 236 }
 237
 238 bool WorkerService::EmbeddedSharedWorkerEnabled() {
 239   static bool disabled = CommandLine::ForCurrentProcess()->HasSwitch(
 240       switches::kDisableEmbeddedSharedWorker);
 241   return !disabled;
 242 }
 243
 244 WorkerServiceImpl* WorkerServiceImpl::GetInstance() {
 245   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 246   return Singleton<WorkerServiceImpl>::get();
 247 }
 248
 249 WorkerServiceImpl::WorkerServiceImpl()
 250     : priority_setter_(new WorkerPrioritySetter()),
 251       next_worker_route_id_(0) {
 252   priority_setter_->Initialize();
 253 }
 254
 255 WorkerServiceImpl::~WorkerServiceImpl() {
 256   // The observers in observers_ can't be used here because they might be
 257   // gone already.
 258 }
 259
 260 void WorkerServiceImpl::PerformTeardownForTesting() {
 261   priority_setter_ = NULL;
 262 }
 263
 264 void WorkerServiceImpl::OnWorkerMessageFilterClosing(
 265     WorkerMessageFilter* filter) {
 266   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 267     iter->FilterShutdown(filter);
 268   }
 269
 270   // See if that process had any queued workers.
 271   for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin();
 272        i != queued_workers_.end();) {
 273     i->RemoveFilters(filter);
 274     if (i->NumFilters() == 0) {
 275       i = queued_workers_.erase(i);
 276     } else {
 277       ++i;
 278     }
 279   }
 280
 281   // Either a worker proceess has shut down, in which case we can start one of
 282   // the queued workers, or a renderer has shut down, in which case it doesn't
 283   // affect anything.  We call this function in both scenarios because then we
 284   // don't have to keep track which filters are from worker processes.
 285   TryStartingQueuedWorker();
 286 }
 287
 288 void WorkerServiceImpl::CreateWorker(
 289     const ViewHostMsg_CreateWorker_Params& params,
 290     int route_id,
 291     WorkerMessageFilter* filter,
 292     ResourceContext* resource_context,
 293     const WorkerStoragePartition& partition,
 294     bool* url_mismatch) {
 295   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 296   *url_mismatch = false;
 297   WorkerProcessHost::WorkerInstance* existing_instance =
 298       FindSharedWorkerInstance(
 299           params.url, params.name, partition, resource_context);
 300   if (existing_instance) {
 301     if (params.url != existing_instance->url()) {
 302       *url_mismatch = true;
 303       return;
 304     }
 305     if (existing_instance->load_failed()) {
 306       filter->Send(new ViewMsg_WorkerScriptLoadFailed(route_id));
 307       return;
 308     }
 309     existing_instance->AddFilter(filter, route_id);
 310     existing_instance->worker_document_set()->Add(
 311         filter, params.document_id, filter->render_process_id(),
 312         params.render_frame_route_id);
 313     filter->Send(new ViewMsg_WorkerCreated(route_id));
 314     return;
 315   }
 316   for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin();
 317        i != queued_workers_.end(); ++i) {
 318     if (i->Matches(params.url, params.name, partition, resource_context) &&
 319         params.url != i->url()) {
 320       *url_mismatch = true;
 321       return;
 322     }
 323   }
 324
 325   // Generate a unique route id for the browser-worker communication that's
 326   // unique among all worker processes.  That way when the worker process sends
 327   // a wrapped IPC message through us, we know which WorkerProcessHost to give
 328   // it to.
 329   WorkerProcessHost::WorkerInstance instance(
 330       params.url,
 331       params.name,
 332       params.content_security_policy,
 333       params.security_policy_type,
 334       next_worker_route_id(),
 335       params.render_frame_route_id,
 336       resource_context,
 337       partition);
 338   instance.AddFilter(filter, route_id);
 339   instance.worker_document_set()->Add(
 340       filter, params.document_id, filter->render_process_id(),
 341       params.render_frame_route_id);
 342
 343   CreateWorkerFromInstance(instance);
 344 }
 345
 346 void WorkerServiceImpl::ForwardToWorker(const IPC::Message& message,
 347                                         WorkerMessageFilter* filter) {
 348   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 349     if (iter->FilterMessage(message, filter))
 350       return;
 351   }
 352
 353   // TODO(jabdelmalek): tell filter that callee is gone
 354 }
 355
 356 void WorkerServiceImpl::DocumentDetached(unsigned long long document_id,
 357                                          WorkerMessageFilter* filter) {
 358   // Any associated shared workers can be shut down.
 359   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter)
 360     iter->DocumentDetached(filter, document_id);
 361
 362   // Remove any queued shared workers for this document.
 363   for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin();
 364        iter != queued_workers_.end();) {
 365
 366     iter->worker_document_set()->Remove(filter, document_id);
 367     if (iter->worker_document_set()->IsEmpty()) {
 368       iter = queued_workers_.erase(iter);
 369       continue;
 370     }
 371     ++iter;
 372   }
 373 }
 374
 375 bool WorkerServiceImpl::CreateWorkerFromInstance(
 376     WorkerProcessHost::WorkerInstance instance) {
 377   if (!CanCreateWorkerProcess(instance)) {
 378     queued_workers_.push_back(instance);
 379     return true;
 380   }
 381
 382   // Remove any queued instances of this worker and copy over the filter to
 383   // this instance.
 384   for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin();
 385        iter != queued_workers_.end();) {
 386     if (iter->Matches(instance.url(), instance.name(),
 387                       instance.partition(), instance.resource_context())) {
 388       DCHECK(iter->NumFilters() == 1);
 389       DCHECK_EQ(instance.url(), iter->url());
 390       WorkerProcessHost::WorkerInstance::FilterInfo filter_info =
 391           iter->GetFilter();
 392       instance.AddFilter(filter_info.filter(), filter_info.route_id());
 393       iter = queued_workers_.erase(iter);
 394     } else {
 395       ++iter;
 396     }
 397   }
 398
 399   WorkerMessageFilter* first_filter = instance.filters().begin()->filter();
 400   WorkerProcessHost* worker = new WorkerProcessHost(
 401       instance.resource_context(), instance.partition());
 402   // TODO(atwilson): This won't work if the message is from a worker process.
 403   // We don't support that yet though (this message is only sent from
 404   // renderers) but when we do, we'll need to add code to pass in the current
 405   // worker's document set for nested workers.
 406   if (!worker->Init(first_filter->render_process_id(),
 407                     instance.render_frame_id())) {
 408     delete worker;
 409     return false;
 410   }
 411
 412   worker->CreateWorker(
 413       instance,
 414       WorkerDevToolsManager::GetInstance()->WorkerCreated(worker, instance));
 415   FOR_EACH_OBSERVER(
 416       WorkerServiceObserver, observers_,
 417       WorkerCreated(instance.url(), instance.name(), worker->GetData().id,
 418                     instance.worker_route_id()));
 419   return true;
 420 }
 421
 422 bool WorkerServiceImpl::CanCreateWorkerProcess(
 423     const WorkerProcessHost::WorkerInstance& instance) {
 424   // Worker can be fired off if *any* parent has room.
 425   const WorkerDocumentSet::DocumentInfoSet& parents =
 426         instance.worker_document_set()->documents();
 427
 428   for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
 429            parents.begin();
 430        parent_iter != parents.end(); ++parent_iter) {
 431     bool hit_total_worker_limit = false;
 432     if (FrameCanCreateWorkerProcess(parent_iter->render_process_id(),
 433                                     parent_iter->render_frame_id(),
 434                                     &hit_total_worker_limit)) {
 435       return true;
 436     }
 437     // Return false if already at the global worker limit (no need to continue
 438     // checking parent tabs).
 439     if (hit_total_worker_limit)
 440       return false;
 441   }
 442   // If we've reached here, none of the parent tabs is allowed to create an
 443   // instance.
 444   return false;
 445 }
 446
 447 bool WorkerServiceImpl::FrameCanCreateWorkerProcess(
 448     int render_process_id,
 449     int render_frame_id,
 450     bool* hit_total_worker_limit) {
 451   int total_workers = 0;
 452   int workers_per_tab = 0;
 453   *hit_total_worker_limit = false;
 454   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 455     for (WorkerProcessHost::Instances::const_iterator cur_instance =
 456              iter->instances().begin();
 457          cur_instance != iter->instances().end(); ++cur_instance) {
 458       total_workers++;
 459       if (total_workers >= kMaxWorkersWhenSeparate) {
 460         *hit_total_worker_limit = true;
 461         return false;
 462       }
 463       if (cur_instance->FrameIsParent(render_process_id, render_frame_id)) {
 464         workers_per_tab++;
 465         if (workers_per_tab >= kMaxWorkersPerFrameWhenSeparate)
 466           return false;
 467       }
 468     }
 469   }
 470
 471   return true;
 472 }
 473
 474 void WorkerServiceImpl::TryStartingQueuedWorker() {
 475   if (queued_workers_.empty())
 476     return;
 477
 478   for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin();
 479        i != queued_workers_.end();) {
 480     if (CanCreateWorkerProcess(*i)) {
 481       WorkerProcessHost::WorkerInstance instance = *i;
 482       queued_workers_.erase(i);
 483       CreateWorkerFromInstance(instance);
 484
 485       // CreateWorkerFromInstance can modify the queued_workers_ list when it
 486       // coalesces queued instances after starting a shared worker, so we
 487       // have to rescan the list from the beginning (our iterator is now
 488       // invalid). This is not a big deal as having any queued workers will be
 489       // rare in practice so the list will be small.
 490       i = queued_workers_.begin();
 491     } else {
 492       ++i;
 493     }
 494   }
 495 }
 496
 497 bool WorkerServiceImpl::GetRendererForWorker(int worker_process_id,
 498                                              int* render_process_id,
 499                                              int* render_frame_id) const {
 500   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 501     if (iter.GetData().id != worker_process_id)
 502       continue;
 503
 504     // This code assumes one worker per process, see function comment in header!
 505     WorkerProcessHost::Instances::const_iterator first_instance =
 506         iter->instances().begin();
 507     if (first_instance == iter->instances().end())
 508       return false;
 509
 510     WorkerDocumentSet::DocumentInfoSet::const_iterator info =
 511         first_instance->worker_document_set()->documents().begin();
 512     *render_process_id = info->render_process_id();
 513     *render_frame_id = info->render_frame_id();
 514     return true;
 515   }
 516   return false;
 517 }
 518
 519 const WorkerProcessHost::WorkerInstance* WorkerServiceImpl::FindWorkerInstance(
 520       int worker_process_id) {
 521   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 522     if (iter.GetData().id != worker_process_id)
 523         continue;
 524
 525     WorkerProcessHost::Instances::const_iterator instance =
 526         iter->instances().begin();
 527     return instance == iter->instances().end() ? NULL : &*instance;
 528   }
 529   return NULL;
 530 }
 531
 532 bool WorkerServiceImpl::TerminateWorker(int process_id, int route_id) {
 533   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 534     if (iter.GetData().id == process_id) {
 535       iter->TerminateWorker(route_id);
 536       return true;
 537     }
 538   }
 539   return false;
 540 }
 541
 542 std::vector<WorkerService::WorkerInfo> WorkerServiceImpl::GetWorkers() {
 543   std::vector<WorkerService::WorkerInfo> results;
 544   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 545     const WorkerProcessHost::Instances& instances = (*iter)->instances();
 546     for (WorkerProcessHost::Instances::const_iterator i = instances.begin();
 547          i != instances.end(); ++i) {
 548       WorkerService::WorkerInfo info;
 549       info.url = i->url();
 550       info.name = i->name();
 551       info.route_id = i->worker_route_id();
 552       info.process_id = iter.GetData().id;
 553       info.handle = iter.GetData().handle;
 554       results.push_back(info);
 555     }
 556   }
 557   return results;
 558 }
 559
 560 void WorkerServiceImpl::AddObserver(WorkerServiceObserver* observer) {
 561   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 562   observers_.AddObserver(observer);
 563 }
 564
 565 void WorkerServiceImpl::RemoveObserver(WorkerServiceObserver* observer) {
 566   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 567   observers_.RemoveObserver(observer);
 568 }
 569
 570 void WorkerServiceImpl::NotifyWorkerDestroyed(
 571     WorkerProcessHost* process,
 572     int worker_route_id) {
 573   WorkerDevToolsManager::GetInstance()->WorkerDestroyed(
 574       process, worker_route_id);
 575   FOR_EACH_OBSERVER(WorkerServiceObserver, observers_,
 576                     WorkerDestroyed(process->GetData().id, worker_route_id));
 577 }
 578
 579 void WorkerServiceImpl::NotifyWorkerProcessCreated() {
 580   priority_setter_->NotifyWorkerProcessCreated();
 581 }
 582
 583 WorkerProcessHost::WorkerInstance* WorkerServiceImpl::FindSharedWorkerInstance(
 584     const GURL& url,
 585     const base::string16& name,
 586     const WorkerStoragePartition& partition,
 587     ResourceContext* resource_context) {
 588   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 589     for (WorkerProcessHost::Instances::iterator instance_iter =
 590              iter->mutable_instances().begin();
 591          instance_iter != iter->mutable_instances().end();
 592          ++instance_iter) {
 593       if (instance_iter->Matches(url, name, partition, resource_context))
 594         return &(*instance_iter);
 595     }
 596   }
 597   return NULL;
 598 }
 599
 600 }  // namespace content