domain.go

// Code generated by cdpgen. DO NOT EDIT.

// Package storage implements the Storage domain.
package storage

import (
	"context"

	"github.com/mafredri/cdp/protocol/internal"
	"github.com/mafredri/cdp/rpcc"
)

// domainClient is a client for the Storage domain.
type domainClient struct{ conn *rpcc.Conn }

// NewClient returns a client for the Storage domain with the connection set to conn.
func NewClient(conn *rpcc.Conn) *domainClient {
	return &domainClient{conn: conn}
}

// GetStorageKeyForFrame invokes the Storage method. Returns a storage key
// given a frame id.
func (d *domainClient) GetStorageKeyForFrame(ctx context.Context, args *GetStorageKeyForFrameArgs) (reply *GetStorageKeyForFrameReply, err error) {
	reply = new(GetStorageKeyForFrameReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.getStorageKeyForFrame", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.getStorageKeyForFrame", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "GetStorageKeyForFrame", Err: err}
	}
	return
}

// ClearDataForOrigin invokes the Storage method. Clears storage for origin.
func (d *domainClient) ClearDataForOrigin(ctx context.Context, args *ClearDataForOriginArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.clearDataForOrigin", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.clearDataForOrigin", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "ClearDataForOrigin", Err: err}
	}
	return
}

// GetCookies invokes the Storage method. Returns all browser cookies.
func (d *domainClient) GetCookies(ctx context.Context, args *GetCookiesArgs) (reply *GetCookiesReply, err error) {
	reply = new(GetCookiesReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.getCookies", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.getCookies", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "GetCookies", Err: err}
	}
	return
}

// SetCookies invokes the Storage method. Sets given cookies.
func (d *domainClient) SetCookies(ctx context.Context, args *SetCookiesArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.setCookies", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.setCookies", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "SetCookies", Err: err}
	}
	return
}

// ClearCookies invokes the Storage method. Clears cookies.
func (d *domainClient) ClearCookies(ctx context.Context, args *ClearCookiesArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.clearCookies", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.clearCookies", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "ClearCookies", Err: err}
	}
	return
}

// GetUsageAndQuota invokes the Storage method. Returns usage and quota in
// bytes.
func (d *domainClient) GetUsageAndQuota(ctx context.Context, args *GetUsageAndQuotaArgs) (reply *GetUsageAndQuotaReply, err error) {
	reply = new(GetUsageAndQuotaReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.getUsageAndQuota", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.getUsageAndQuota", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "GetUsageAndQuota", Err: err}
	}
	return
}

// OverrideQuotaForOrigin invokes the Storage method. Override quota for the
// specified origin
func (d *domainClient) OverrideQuotaForOrigin(ctx context.Context, args *OverrideQuotaForOriginArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.overrideQuotaForOrigin", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.overrideQuotaForOrigin", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "OverrideQuotaForOrigin", Err: err}
	}
	return
}

// TrackCacheStorageForOrigin invokes the Storage method. Registers origin to
// be notified when an update occurs to its cache storage list.
func (d *domainClient) TrackCacheStorageForOrigin(ctx context.Context, args *TrackCacheStorageForOriginArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.trackCacheStorageForOrigin", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.trackCacheStorageForOrigin", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "TrackCacheStorageForOrigin", Err: err}
	}
	return
}

// TrackIndexedDBForOrigin invokes the Storage method. Registers origin to be
// notified when an update occurs to its IndexedDB.
func (d *domainClient) TrackIndexedDBForOrigin(ctx context.Context, args *TrackIndexedDBForOriginArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.trackIndexedDBForOrigin", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.trackIndexedDBForOrigin", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "TrackIndexedDBForOrigin", Err: err}
	}
	return
}

// UntrackCacheStorageForOrigin invokes the Storage method. Unregisters origin
// from receiving notifications for cache storage.
func (d *domainClient) UntrackCacheStorageForOrigin(ctx context.Context, args *UntrackCacheStorageForOriginArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.untrackCacheStorageForOrigin", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.untrackCacheStorageForOrigin", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "UntrackCacheStorageForOrigin", Err: err}
	}
	return
}

// UntrackIndexedDBForOrigin invokes the Storage method. Unregisters origin
// from receiving notifications for IndexedDB.
func (d *domainClient) UntrackIndexedDBForOrigin(ctx context.Context, args *UntrackIndexedDBForOriginArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.untrackIndexedDBForOrigin", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.untrackIndexedDBForOrigin", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "UntrackIndexedDBForOrigin", Err: err}
	}
	return
}

// GetTrustTokens invokes the Storage method. Returns the number of stored
// Trust Tokens per issuer for the current browsing context.
func (d *domainClient) GetTrustTokens(ctx context.Context) (reply *GetTrustTokensReply, err error) {
	reply = new(GetTrustTokensReply)
	err = rpcc.Invoke(ctx, "Storage.getTrustTokens", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "GetTrustTokens", Err: err}
	}
	return
}

// ClearTrustTokens invokes the Storage method. Removes all Trust Tokens
// issued by the provided issuerOrigin. Leaves other stored data, including the
// issuer's Redemption Records, intact.
func (d *domainClient) ClearTrustTokens(ctx context.Context, args *ClearTrustTokensArgs) (reply *ClearTrustTokensReply, err error) {
	reply = new(ClearTrustTokensReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.clearTrustTokens", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.clearTrustTokens", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "ClearTrustTokens", Err: err}
	}
	return
}

// GetInterestGroupDetails invokes the Storage method. Gets details for a
// named interest group.
func (d *domainClient) GetInterestGroupDetails(ctx context.Context, args *GetInterestGroupDetailsArgs) (reply *GetInterestGroupDetailsReply, err error) {
	reply = new(GetInterestGroupDetailsReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.getInterestGroupDetails", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.getInterestGroupDetails", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "GetInterestGroupDetails", Err: err}
	}
	return
}

// SetInterestGroupTracking invokes the Storage method. Enables/Disables
// issuing of interestGroupAccessed events.
func (d *domainClient) SetInterestGroupTracking(ctx context.Context, args *SetInterestGroupTrackingArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Storage.setInterestGroupTracking", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Storage.setInterestGroupTracking", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Storage", Op: "SetInterestGroupTracking", Err: err}
	}
	return
}

func (d *domainClient) CacheStorageContentUpdated(ctx context.Context) (CacheStorageContentUpdatedClient, error) {
	s, err := rpcc.NewStream(ctx, "Storage.cacheStorageContentUpdated", d.conn)
	if err != nil {
		return nil, err
	}
	return &cacheStorageContentUpdatedClient{Stream: s}, nil
}

type cacheStorageContentUpdatedClient struct{ rpcc.Stream }

// GetStream returns the original Stream for use with cdp.Sync.
func (c *cacheStorageContentUpdatedClient) GetStream() rpcc.Stream { return c.Stream }

func (c *cacheStorageContentUpdatedClient) Recv() (*CacheStorageContentUpdatedReply, error) {
	event := new(CacheStorageContentUpdatedReply)
	if err := c.RecvMsg(event); err != nil {
		return nil, &internal.OpError{Domain: "Storage", Op: "CacheStorageContentUpdated Recv", Err: err}
	}
	return event, nil
}

func (d *domainClient) CacheStorageListUpdated(ctx context.Context) (CacheStorageListUpdatedClient, error) {
	s, err := rpcc.NewStream(ctx, "Storage.cacheStorageListUpdated", d.conn)
	if err != nil {
		return nil, err
	}
	return &cacheStorageListUpdatedClient{Stream: s}, nil
}

type cacheStorageListUpdatedClient struct{ rpcc.Stream }

// GetStream returns the original Stream for use with cdp.Sync.
func (c *cacheStorageListUpdatedClient) GetStream() rpcc.Stream { return c.Stream }

func (c *cacheStorageListUpdatedClient) Recv() (*CacheStorageListUpdatedReply, error) {
	event := new(CacheStorageListUpdatedReply)
	if err := c.RecvMsg(event); err != nil {
		return nil, &internal.OpError{Domain: "Storage", Op: "CacheStorageListUpdated Recv", Err: err}
	}
	return event, nil
}

func (d *domainClient) IndexedDBContentUpdated(ctx context.Context) (IndexedDBContentUpdatedClient, error) {
	s, err := rpcc.NewStream(ctx, "Storage.indexedDBContentUpdated", d.conn)
	if err != nil {
		return nil, err
	}
	return &indexedDBContentUpdatedClient{Stream: s}, nil
}

type indexedDBContentUpdatedClient struct{ rpcc.Stream }

// GetStream returns the original Stream for use with cdp.Sync.
func (c *indexedDBContentUpdatedClient) GetStream() rpcc.Stream { return c.Stream }

func (c *indexedDBContentUpdatedClient) Recv() (*IndexedDBContentUpdatedReply, error) {
	event := new(IndexedDBContentUpdatedReply)
	if err := c.RecvMsg(event); err != nil {
		return nil, &internal.OpError{Domain: "Storage", Op: "IndexedDBContentUpdated Recv", Err: err}
	}
	return event, nil
}

func (d *domainClient) IndexedDBListUpdated(ctx context.Context) (IndexedDBListUpdatedClient, error) {
	s, err := rpcc.NewStream(ctx, "Storage.indexedDBListUpdated", d.conn)
	if err != nil {
		return nil, err
	}
	return &indexedDBListUpdatedClient{Stream: s}, nil
}

type indexedDBListUpdatedClient struct{ rpcc.Stream }

// GetStream returns the original Stream for use with cdp.Sync.
func (c *indexedDBListUpdatedClient) GetStream() rpcc.Stream { return c.Stream }

func (c *indexedDBListUpdatedClient) Recv() (*IndexedDBListUpdatedReply, error) {
	event := new(IndexedDBListUpdatedReply)
	if err := c.RecvMsg(event); err != nil {
		return nil, &internal.OpError{Domain: "Storage", Op: "IndexedDBListUpdated Recv", Err: err}
	}
	return event, nil
}

func (d *domainClient) InterestGroupAccessed(ctx context.Context) (InterestGroupAccessedClient, error) {
	s, err := rpcc.NewStream(ctx, "Storage.interestGroupAccessed", d.conn)
	if err != nil {
		return nil, err
	}
	return &interestGroupAccessedClient{Stream: s}, nil
}

type interestGroupAccessedClient struct{ rpcc.Stream }

// GetStream returns the original Stream for use with cdp.Sync.
func (c *interestGroupAccessedClient) GetStream() rpcc.Stream { return c.Stream }

func (c *interestGroupAccessedClient) Recv() (*InterestGroupAccessedReply, error) {
	event := new(InterestGroupAccessedReply)
	if err := c.RecvMsg(event); err != nil {
		return nil, &internal.OpError{Domain: "Storage", Op: "InterestGroupAccessed Recv", Err: err}
	}
	return event, nil
}