Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-03 02:25:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1277705 - Remove more notification-related files (r=dvander)

Browse Source
This commit is contained in:
Bill McCloskey 2016-06-01 19:11:44 -07:00
parent db00162c58
commit 0a5b384f55
4 changed files with 0 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
ipc/chromium/src/chrome/common/notification_details.h
View File

@ -1,54 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
// Copyright (c) 2006-2008 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.
// This file defines the type used to provide details for NotificationService
// notifications.
#ifndef CHROME_COMMON_NOTIFICATION_DETAILS_H__
#define CHROME_COMMON_NOTIFICATION_DETAILS_H__
#include "base/basictypes.h"
// Do not declare a NotificationDetails directly--use either
// "Details<detailsclassname>(detailsclasspointer)" or
// NotificationService::NoDetails().
class NotificationDetails {
public:
NotificationDetails() : ptr_(NULL) {}
NotificationDetails(const NotificationDetails& other) : ptr_(other.ptr_) {}
~NotificationDetails() {}
// NotificationDetails can be used as the index for a map; this method
// returns the pointer to the current details as an identifier, for use as a
// map index.
uintptr_t map_key() const { return reinterpret_cast<uintptr_t>(ptr_); }
bool operator!=(const NotificationDetails& other) const {
return ptr_ != other.ptr_;
}
bool operator==(const NotificationDetails& other) const {
return ptr_ == other.ptr_;
}
protected:
explicit NotificationDetails(void* ptr) : ptr_(ptr) {}
void* ptr_;
};
template <class T>
class Details : public NotificationDetails {
public:
explicit Details(T* ptr) : NotificationDetails(ptr) {}
explicit Details(const NotificationDetails& other)
: NotificationDetails(other) {}
T* operator->() const { return ptr(); }
T* ptr() const { return static_cast<T*>(ptr_); }
};
#endif // CHROME_COMMON_NOTIFICATION_DETAILS_H__

25
ipc/chromium/src/chrome/common/notification_observer.h
View File

@ -1,25 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
// Copyright (c) 2009 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.
#ifndef CHROME_COMMON_NOTIFICATION_OBSERVER_H_
#define CHROME_COMMON_NOTIFICATION_OBSERVER_H_
class NotificationDetails;
class NotificationSource;
class NotificationType;
// This is the base class for notification observers. When a matching
// notification is posted to the notification service, Observe is called.
class NotificationObserver {
public:
virtual ~NotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details) = 0;
};
#endif // CHROME_COMMON_NOTIFICATION_OBSERVER_H_

55
ipc/chromium/src/chrome/common/notification_registrar.h
View File

@ -1,55 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
// Copyright (c) 2006-2008 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.
#ifndef CHROME_COMMON_NOTIFICATION_REGISTRAR_H_
#define CHROME_COMMON_NOTIFICATION_REGISTRAR_H_
#include <vector>
#include "base/basictypes.h"
#include "chrome/common/notification_observer.h"
// Aids in registering for notifications and ensures that all registered
// notifications are unregistered when the class is destroyed.
//
// The intended use is that you make a NotificationRegistrar member in your
// class and use it to register your notifications instead of going through the
// notification service directly. It will automatically unregister them for
// you.
class NotificationRegistrar {
public:
// This class must not be derived from (we don't have a virtual destructor so
// it won't work). Instead, use it as a member in your class.
NotificationRegistrar();
~NotificationRegistrar();
// Wrappers around NotificationService::[Add|Remove]Observer.
void Add(NotificationObserver* observer,
NotificationType type,
const NotificationSource& source);
void Remove(NotificationObserver* observer,
NotificationType type,
const NotificationSource& source);
// Unregisters all notifications.
void RemoveAll();
private:
struct Record;
// We keep registered notifications in a simple vector. This means we'll do
// brute-force searches when removing them individually, but individual
// removal is uncommon, and there will typically only be a couple of
// notifications anyway.
typedef std::vector<Record> RecordVector;
// Lists all notifications we're currently registered for.
RecordVector registered_;
DISALLOW_COPY_AND_ASSIGN(NotificationRegistrar);
};
#endif // CHROME_COMMON_NOTIFICATION_REGISTRAR_H_

53
ipc/chromium/src/chrome/common/notification_source.h
View File

@ -1,53 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
// Copyright (c) 2006-2008 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.
// This file defines the type used to provide sources for NotificationService
// notifications.
#ifndef CHROME_COMMON_NOTIFICATION_SOURCE_H__
#define CHROME_COMMON_NOTIFICATION_SOURCE_H__
#include "base/basictypes.h"
// Do not declare a NotificationSource directly--use either
// "Source<sourceclassname>(sourceclasspointer)" or
// NotificationService::AllSources().
class NotificationSource {
public:
NotificationSource(const NotificationSource& other) : ptr_(other.ptr_) { }
~NotificationSource() {}
// NotificationSource can be used as the index for a map; this method
// returns the pointer to the current source as an identifier, for use as a
// map index.
uintptr_t map_key() const { return reinterpret_cast<uintptr_t>(ptr_); }
bool operator!=(const NotificationSource& other) const {
return ptr_ != other.ptr_;
}
bool operator==(const NotificationSource& other) const {
return ptr_ == other.ptr_;
}
protected:
explicit NotificationSource(void* ptr) : ptr_(ptr) {}
void* ptr_;
};
template <class T>
class Source : public NotificationSource {
public:
explicit Source(T* ptr) : NotificationSource(ptr) {}
explicit Source(const NotificationSource& other)
: NotificationSource(other) {}
T* operator->() const { return ptr(); }
T* ptr() const { return static_cast<T*>(ptr_); }
};
#endif // CHROME_COMMON_NOTIFICATION_SOURCE_H__